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>
33 #define PREALLOCATED_EXECUTION_STACK 10
35 /* Facilities Quarks */
39 LTT_FACILITY_KERNEL_ARCH
,
42 LTT_FACILITY_STATEDUMP
,
43 LTT_FACILITY_USER_GENERIC
;
48 LTT_EVENT_SYSCALL_ENTRY
,
49 LTT_EVENT_SYSCALL_EXIT
,
54 LTT_EVENT_SOFT_IRQ_ENTRY
,
55 LTT_EVENT_SOFT_IRQ_EXIT
,
56 LTT_EVENT_SCHEDCHANGE
,
58 LTT_EVENT_KERNEL_THREAD
,
62 LTT_EVENT_ENUM_PROCESS_STATE
,
63 LTT_EVENT_FUNCTION_ENTRY
,
64 LTT_EVENT_FUNCTION_EXIT
,
65 LTT_EVENT_THREAD_BRAND
;
73 LTT_FIELD_SOFT_IRQ_ID
,
91 LTTV_STATE_MODE_UNKNOWN
,
99 LTTV_STATE_SUBMODE_UNKNOWN
,
100 LTTV_STATE_SUBMODE_NONE
;
104 LTTV_STATE_UNBRANDED
,
105 LTTV_STATE_WAIT_FORK
,
114 LTTV_STATE_USER_THREAD
,
115 LTTV_STATE_KERNEL_THREAD
;
118 LTTV_STATE_TRACEFILES
,
119 LTTV_STATE_PROCESSES
,
121 LTTV_STATE_RUNNING_PROCESS
,
123 LTTV_STATE_SAVED_STATES
,
124 LTTV_STATE_SAVED_STATES_TIME
,
127 LTTV_STATE_NAME_TABLES
,
128 LTTV_STATE_TRACE_STATE_USE_COUNT
;
130 static void create_max_time(LttvTraceState
*tcs
);
132 static void get_max_time(LttvTraceState
*tcs
);
134 static void free_max_time(LttvTraceState
*tcs
);
136 static void create_name_tables(LttvTraceState
*tcs
);
138 static void get_name_tables(LttvTraceState
*tcs
);
140 static void free_name_tables(LttvTraceState
*tcs
);
142 static void free_saved_state(LttvTraceState
*tcs
);
144 static void lttv_state_free_process_table(GHashTable
*processes
);
147 void lttv_state_save(LttvTraceState
*self
, LttvAttribute
*container
)
149 LTTV_TRACE_STATE_GET_CLASS(self
)->state_save(self
, container
);
153 void lttv_state_restore(LttvTraceState
*self
, LttvAttribute
*container
)
155 LTTV_TRACE_STATE_GET_CLASS(self
)->state_restore(self
, container
);
159 void lttv_state_state_saved_free(LttvTraceState
*self
,
160 LttvAttribute
*container
)
162 LTTV_TRACE_STATE_GET_CLASS(self
)->state_saved_free(self
, container
);
166 guint
process_hash(gconstpointer key
)
168 guint pid
= ((const LttvProcessState
*)key
)->pid
;
169 return (pid
>>8 ^ pid
>>4 ^ pid
>>2 ^ pid
) ;
173 /* If the hash table hash function is well distributed,
174 * the process_equal should compare different pid */
175 gboolean
process_equal(gconstpointer a
, gconstpointer b
)
177 const LttvProcessState
*process_a
, *process_b
;
180 process_a
= (const LttvProcessState
*)a
;
181 process_b
= (const LttvProcessState
*)b
;
183 if(likely(process_a
->pid
!= process_b
->pid
)) ret
= FALSE
;
184 else if(likely(process_a
->pid
== 0 &&
185 process_a
->cpu
!= process_b
->cpu
)) ret
= FALSE
;
190 static void delete_usertrace(gpointer key
, gpointer value
, gpointer user_data
)
192 g_tree_destroy((GTree
*)value
);
195 static void lttv_state_free_usertraces(GHashTable
*usertraces
)
197 g_hash_table_foreach(usertraces
, delete_usertrace
, NULL
);
198 g_hash_table_destroy(usertraces
);
204 restore_init_state(LttvTraceState
*self
)
208 LttvTracefileState
*tfcs
;
210 LttTime start_time
, end_time
;
212 /* Free the process tables */
213 if(self
->processes
!= NULL
) lttv_state_free_process_table(self
->processes
);
214 if(self
->usertraces
!= NULL
) lttv_state_free_usertraces(self
->usertraces
);
215 self
->processes
= g_hash_table_new(process_hash
, process_equal
);
216 self
->usertraces
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
219 /* Seek time to beginning */
220 // Mathieu : fix : don't seek traceset here : causes inconsistency in seek
221 // closest. It's the tracecontext job to seek the trace to the beginning
222 // anyway : the init state might be used at the middle of the trace as well...
223 //g_tree_destroy(self->parent.ts_context->pqueue);
224 //self->parent.ts_context->pqueue = g_tree_new(compare_tracefile);
226 ltt_trace_time_span_get(self
->parent
.t
, &start_time
, &end_time
);
228 //lttv_process_trace_seek_time(&self->parent, ltt_time_zero);
230 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
232 /* Put the per cpu running_process to beginning state : process 0. */
233 for(i
=0; i
< nb_cpus
; i
++) {
234 self
->running_process
[i
] = lttv_state_create_process(self
, NULL
, i
, 0, 0,
235 LTTV_STATE_UNNAMED
, &start_time
);
236 self
->running_process
[i
]->state
->s
= LTTV_STATE_RUN
;
237 self
->running_process
[i
]->cpu
= i
;
241 nb_tracefile
= self
->parent
.tracefiles
->len
;
243 for(i
= 0 ; i
< nb_tracefile
; i
++) {
245 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
246 LttvTracefileContext
*, i
));
247 ltt_trace_time_span_get(self
->parent
.t
, &tfcs
->parent
.timestamp
, NULL
);
248 // tfcs->saved_position = 0;
249 tfcs
->process
= lttv_state_create_process(tfcs
, NULL
,0);
250 tfcs
->process
->state
->s
= LTTV_STATE_RUN
;
251 tfcs
->process
->last_cpu
= tfcs
->cpu_name
;
252 tfcs
->process
->last_cpu_index
= ltt_tracefile_num(((LttvTracefileContext
*)tfcs
)->tf
);
257 //static LttTime time_zero = {0,0};
259 static gint
compare_usertraces(gconstpointer a
, gconstpointer b
,
262 const LttTime
*t1
= (const LttTime
*)a
;
263 const LttTime
*t2
= (const LttTime
*)b
;
265 return ltt_time_compare(*t1
, *t2
);
268 static void free_usertrace_key(gpointer data
)
274 init(LttvTracesetState
*self
, LttvTraceset
*ts
)
276 guint i
, j
, nb_trace
, nb_tracefile
;
278 LttvTraceContext
*tc
;
282 LttvTracefileState
*tfcs
;
284 LttvAttributeValue v
;
286 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
287 init((LttvTracesetContext
*)self
, ts
);
289 nb_trace
= lttv_traceset_number(ts
);
290 for(i
= 0 ; i
< nb_trace
; i
++) {
291 tc
= self
->parent
.traces
[i
];
292 tcs
= LTTV_TRACE_STATE(tc
);
293 tcs
->save_interval
= LTTV_STATE_SAVE_INTERVAL
;
294 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_TRACE_STATE_USE_COUNT
,
298 if(*(v
.v_uint
) == 1) {
299 create_name_tables(tcs
);
300 create_max_time(tcs
);
302 get_name_tables(tcs
);
305 nb_tracefile
= tc
->tracefiles
->len
;
306 tcs
->processes
= NULL
;
307 tcs
->usertraces
= NULL
;
308 tcs
->running_process
= g_new(LttvProcessState
*,
309 ltt_trace_get_num_cpu(tc
->t
));
310 restore_init_state(tcs
);
311 for(j
= 0 ; j
< nb_tracefile
; j
++) {
313 LTTV_TRACEFILE_STATE(g_array_index(tc
->tracefiles
,
314 LttvTracefileContext
*, j
));
315 tfcs
->tracefile_name
= ltt_tracefile_name(tfcs
->parent
.tf
);
316 tfcs
->cpu
= ltt_tracefile_cpu(tfcs
->parent
.tf
);
318 if(ltt_tracefile_tid(tfcs
->parent
.tf
) != 0) {
319 /* It's a Usertrace */
320 LttvProcessState
*process
;
322 ltt_interpolate_time_from_tsc(tfcs
->parent
.tf
,
323 ltt_tracefile_creation(tfcs
->parent
.tf
));
324 process
= lttv_state_find_process_or_create(
326 0, ltt_tracefile_tid(tfcs
->parent
.tf
),
328 process
->usertrace
= tfcs
;
332 if(ltt_tracefile_tid(tfcs
->parent
.tf
) != 0) {
333 /* It's a Usertrace */
334 guint tid
= ltt_tracefile_tid(tfcs
->parent
.tf
);
335 GTree
*usertrace_tree
= (GTree
*)g_hash_table_lookup(tcs
->usertraces
,
337 if(!usertrace_tree
) {
338 usertrace_tree
= g_tree_new_full(compare_usertraces
,
339 NULL
, free_usertrace_key
, NULL
);
340 g_hash_table_insert(tcs
->usertraces
,
341 (gpointer
)tid
, usertrace_tree
);
343 LttTime
*timestamp
= g_new(LttTime
, 1);
344 *timestamp
= ltt_interpolate_time_from_tsc(tfcs
->parent
.tf
,
345 ltt_tracefile_creation(tfcs
->parent
.tf
));
346 g_tree_insert(usertrace_tree
, timestamp
, tfcs
);
354 fini(LttvTracesetState
*self
)
360 LttvTracefileState
*tfcs
;
362 LttvAttributeValue v
;
364 nb_trace
= lttv_traceset_number(LTTV_TRACESET_CONTEXT(self
)->ts
);
365 for(i
= 0 ; i
< nb_trace
; i
++) {
366 tcs
= (LttvTraceState
*)(LTTV_TRACESET_CONTEXT(self
)->traces
[i
]);
367 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_TRACE_STATE_USE_COUNT
,
370 g_assert(*(v
.v_uint
) != 0);
373 if(*(v
.v_uint
) == 0) {
374 free_name_tables(tcs
);
376 free_saved_state(tcs
);
378 g_free(tcs
->running_process
);
379 tcs
->running_process
= NULL
;
380 lttv_state_free_process_table(tcs
->processes
);
381 lttv_state_free_usertraces(tcs
->usertraces
);
382 tcs
->processes
= NULL
;
383 tcs
->usertraces
= NULL
;
385 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
386 fini((LttvTracesetContext
*)self
);
390 static LttvTracesetContext
*
391 new_traceset_context(LttvTracesetContext
*self
)
393 return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE
, NULL
));
397 static LttvTraceContext
*
398 new_trace_context(LttvTracesetContext
*self
)
400 return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE
, NULL
));
404 static LttvTracefileContext
*
405 new_tracefile_context(LttvTracesetContext
*self
)
407 return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE
, NULL
));
411 /* Write the process state of the trace */
413 static void write_process_state(gpointer key
, gpointer value
,
416 LttvProcessState
*process
;
418 LttvExecutionState
*es
;
420 FILE *fp
= (FILE *)user_data
;
424 process
= (LttvProcessState
*)value
;
426 " <PROCESS CORE=%p PID=%u PPID=%u TYPE=\"%s\"CTIME_S=%lu CTIME_NS=%lu NAME=\"%s\" BRAND=\"%s\" CPU=\"%u\">\n",
427 process
, process
->pid
, process
->ppid
, g_quark_to_string(process
->type
),
428 process
->creation_time
.tv_sec
,
429 process
->creation_time
.tv_nsec
, g_quark_to_string(process
->name
),
430 g_quark_to_string(process
->brand
),
433 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
434 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
435 fprintf(fp
, " <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
436 g_quark_to_string(es
->t
), g_quark_to_string(es
->n
),
437 es
->entry
.tv_sec
, es
->entry
.tv_nsec
);
438 fprintf(fp
, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
439 es
->change
.tv_sec
, es
->change
.tv_nsec
, g_quark_to_string(es
->s
));
441 fprintf(fp
, " </PROCESS>\n");
445 void lttv_state_write(LttvTraceState
*self
, LttTime t
, FILE *fp
)
447 guint i
, nb_tracefile
, nb_block
, offset
;
450 LttvTracefileState
*tfcs
;
454 LttEventPosition
*ep
;
458 ep
= ltt_event_position_new();
460 fprintf(fp
,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t
.tv_sec
, t
.tv_nsec
);
462 g_hash_table_foreach(self
->processes
, write_process_state
, fp
);
464 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
465 for(i
=0;i
<nb_cpus
;i
++) {
466 fprintf(fp
,"<CPU NUM=%u RUNNING_PROCESS=%u>\n",
467 i
, self
->running_process
[i
]->pid
);
470 nb_tracefile
= self
->parent
.tracefiles
->len
;
472 for(i
= 0 ; i
< nb_tracefile
; i
++) {
474 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
475 LttvTracefileContext
*, i
));
476 fprintf(fp
, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
477 tfcs
->parent
.timestamp
.tv_sec
,
478 tfcs
->parent
.timestamp
.tv_nsec
);
479 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
480 if(e
== NULL
) fprintf(fp
,"/>\n");
482 ltt_event_position(e
, ep
);
483 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
484 fprintf(fp
, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block
, offset
,
489 fprintf(fp
,"</PROCESS_STATE>");
493 /* Copy each process from an existing hash table to a new one */
495 static void copy_process_state(gpointer key
, gpointer value
,gpointer user_data
)
497 LttvProcessState
*process
, *new_process
;
499 GHashTable
*new_processes
= (GHashTable
*)user_data
;
503 process
= (LttvProcessState
*)value
;
504 new_process
= g_new(LttvProcessState
, 1);
505 *new_process
= *process
;
506 new_process
->execution_stack
= g_array_sized_new(FALSE
, FALSE
,
507 sizeof(LttvExecutionState
), PREALLOCATED_EXECUTION_STACK
);
508 new_process
->execution_stack
=
509 g_array_set_size(new_process
->execution_stack
,
510 process
->execution_stack
->len
);
511 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
512 g_array_index(new_process
->execution_stack
, LttvExecutionState
, i
) =
513 g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
515 new_process
->state
= &g_array_index(new_process
->execution_stack
,
516 LttvExecutionState
, new_process
->execution_stack
->len
- 1);
517 new_process
->user_stack
= g_array_sized_new(FALSE
, FALSE
,
519 new_process
->user_stack
=
520 g_array_set_size(new_process
->user_stack
,
521 process
->user_stack
->len
);
522 for(i
= 0 ; i
< process
->user_stack
->len
; i
++) {
523 g_array_index(new_process
->user_stack
, guint64
, i
) =
524 g_array_index(process
->user_stack
, guint64
, i
);
526 new_process
->current_function
= process
->current_function
;
527 g_hash_table_insert(new_processes
, new_process
, new_process
);
531 static GHashTable
*lttv_state_copy_process_table(GHashTable
*processes
)
533 GHashTable
*new_processes
= g_hash_table_new(process_hash
, process_equal
);
535 g_hash_table_foreach(processes
, copy_process_state
, new_processes
);
536 return new_processes
;
540 /* The saved state for each trace contains a member "processes", which
541 stores a copy of the process table, and a member "tracefiles" with
542 one entry per tracefile. Each tracefile has a "process" member pointing
543 to the current process and a "position" member storing the tracefile
544 position (needed to seek to the current "next" event. */
546 static void state_save(LttvTraceState
*self
, LttvAttribute
*container
)
548 guint i
, nb_tracefile
, nb_cpus
;
550 LttvTracefileState
*tfcs
;
552 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
554 guint
*running_process
;
556 LttvAttributeType type
;
558 LttvAttributeValue value
;
560 LttvAttributeName name
;
562 LttEventPosition
*ep
;
564 tracefiles_tree
= lttv_attribute_find_subdir(container
,
565 LTTV_STATE_TRACEFILES
);
567 value
= lttv_attribute_add(container
, LTTV_STATE_PROCESSES
,
569 *(value
.v_pointer
) = lttv_state_copy_process_table(self
->processes
);
571 /* Add the currently running processes array */
572 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
573 running_process
= g_new(guint
, nb_cpus
);
574 for(i
=0;i
<nb_cpus
;i
++) {
575 running_process
[i
] = self
->running_process
[i
]->pid
;
577 value
= lttv_attribute_add(container
, LTTV_STATE_RUNNING_PROCESS
,
579 *(value
.v_pointer
) = running_process
;
581 g_info("State save");
583 nb_tracefile
= self
->parent
.tracefiles
->len
;
585 for(i
= 0 ; i
< nb_tracefile
; i
++) {
587 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
588 LttvTracefileContext
*, i
));
589 tracefile_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
590 value
= lttv_attribute_add(tracefiles_tree
, i
,
592 *(value
.v_gobject
) = (GObject
*)tracefile_tree
;
594 value
= lttv_attribute_add(tracefile_tree
, LTTV_STATE_PROCESS
,
596 *(value
.v_uint
) = tfcs
->process
->pid
;
598 value
= lttv_attribute_add(tracefile_tree
, LTTV_STATE_EVENT
,
600 /* Only save the position if the tfs has not infinite time. */
601 //if(!g_tree_lookup(self->parent.ts_context->pqueue, &tfcs->parent)
602 // && current_tfcs != tfcs) {
603 if(ltt_time_compare(tfcs
->parent
.timestamp
, ltt_time_infinite
) == 0) {
604 *(value
.v_pointer
) = NULL
;
606 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
607 ep
= ltt_event_position_new();
608 ltt_event_position(e
, ep
);
609 *(value
.v_pointer
) = ep
;
611 guint nb_block
, offset
;
614 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
615 g_info("Block %u offset %u tsc %llu time %lu.%lu", nb_block
, offset
,
617 tfcs
->parent
.timestamp
.tv_sec
, tfcs
->parent
.timestamp
.tv_nsec
);
623 static void state_restore(LttvTraceState
*self
, LttvAttribute
*container
)
625 guint i
, nb_tracefile
, pid
, nb_cpus
;
627 LttvTracefileState
*tfcs
;
629 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
631 guint
*running_process
;
633 LttvAttributeType type
;
635 LttvAttributeValue value
;
637 LttvAttributeName name
;
641 LttEventPosition
*ep
;
643 LttvTracesetContext
*tsc
= self
->parent
.ts_context
;
645 tracefiles_tree
= lttv_attribute_find_subdir(container
,
646 LTTV_STATE_TRACEFILES
);
648 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_PROCESSES
,
650 g_assert(type
== LTTV_POINTER
);
651 lttv_state_free_process_table(self
->processes
);
652 self
->processes
= lttv_state_copy_process_table(*(value
.v_pointer
));
654 /* Add the currently running processes array */
655 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
656 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RUNNING_PROCESS
,
658 g_assert(type
== LTTV_POINTER
);
659 running_process
= *(value
.v_pointer
);
660 for(i
=0;i
<nb_cpus
;i
++) {
661 pid
= running_process
[i
];
662 self
->running_process
[i
] = lttv_state_find_process(self
, i
, pid
);
663 g_assert(self
->running_process
[i
] != NULL
);
667 nb_tracefile
= self
->parent
.tracefiles
->len
;
669 //g_tree_destroy(tsc->pqueue);
670 //tsc->pqueue = g_tree_new(compare_tracefile);
672 for(i
= 0 ; i
< nb_tracefile
; i
++) {
674 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
675 LttvTracefileContext
*, i
));
676 type
= lttv_attribute_get(tracefiles_tree
, i
, &name
, &value
, &is_named
);
677 g_assert(type
== LTTV_GOBJECT
);
678 tracefile_tree
= *((LttvAttribute
**)(value
.v_gobject
));
680 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_PROCESS
,
682 g_assert(type
== LTTV_UINT
);
683 pid
= *(value
.v_uint
);
684 tfcs
->process
= lttv_state_find_process_or_create(tfcs
, pid
);
686 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_EVENT
,
688 g_assert(type
== LTTV_POINTER
);
689 //g_assert(*(value.v_pointer) != NULL);
690 ep
= *(value
.v_pointer
);
691 g_assert(tfcs
->parent
.t_context
!= NULL
);
693 LttvTracefileContext
*tfc
= LTTV_TRACEFILE_CONTEXT(tfcs
);
694 g_tree_remove(tsc
->pqueue
, tfc
);
697 g_assert(ltt_tracefile_seek_position(tfc
->tf
, ep
) == 0);
698 tfc
->timestamp
= ltt_event_time(ltt_tracefile_get_event(tfc
->tf
));
699 g_assert(ltt_time_compare(tfc
->timestamp
, ltt_time_infinite
) != 0);
700 g_tree_insert(tsc
->pqueue
, tfc
, tfc
);
701 g_info("Restoring state for a tf at time %lu.%lu", tfc
->timestamp
.tv_sec
, tfc
->timestamp
.tv_nsec
);
703 tfc
->timestamp
= ltt_time_infinite
;
709 static void state_saved_free(LttvTraceState
*self
, LttvAttribute
*container
)
711 guint i
, nb_tracefile
, nb_cpus
;
713 LttvTracefileState
*tfcs
;
715 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
717 guint
*running_process
;
719 LttvAttributeType type
;
721 LttvAttributeValue value
;
723 LttvAttributeName name
;
727 LttEventPosition
*ep
;
729 tracefiles_tree
= lttv_attribute_find_subdir(container
,
730 LTTV_STATE_TRACEFILES
);
731 g_object_ref(G_OBJECT(tracefiles_tree
));
732 lttv_attribute_remove_by_name(container
, LTTV_STATE_TRACEFILES
);
734 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_PROCESSES
,
736 g_assert(type
== LTTV_POINTER
);
737 lttv_state_free_process_table(*(value
.v_pointer
));
738 *(value
.v_pointer
) = NULL
;
739 lttv_attribute_remove_by_name(container
, LTTV_STATE_PROCESSES
);
741 /* Free running processes array */
742 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
743 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RUNNING_PROCESS
,
745 g_assert(type
== LTTV_POINTER
);
746 running_process
= *(value
.v_pointer
);
747 g_free(running_process
);
749 nb_tracefile
= self
->parent
.tracefiles
->len
;
751 for(i
= 0 ; i
< nb_tracefile
; i
++) {
753 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
754 LttvTracefileContext
*, i
));
755 type
= lttv_attribute_get(tracefiles_tree
, i
, &name
, &value
, &is_named
);
756 g_assert(type
== LTTV_GOBJECT
);
757 tracefile_tree
= *((LttvAttribute
**)(value
.v_gobject
));
759 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_EVENT
,
761 g_assert(type
== LTTV_POINTER
);
762 if(*(value
.v_pointer
) != NULL
) g_free(*(value
.v_pointer
));
764 g_object_unref(G_OBJECT(tracefiles_tree
));
768 static void free_saved_state(LttvTraceState
*self
)
772 LttvAttributeType type
;
774 LttvAttributeValue value
;
776 LttvAttributeName name
;
780 LttvAttribute
*saved_states
;
782 saved_states
= lttv_attribute_find_subdir(self
->parent
.t_a
,
783 LTTV_STATE_SAVED_STATES
);
785 nb
= lttv_attribute_get_number(saved_states
);
786 for(i
= 0 ; i
< nb
; i
++) {
787 type
= lttv_attribute_get(saved_states
, i
, &name
, &value
, &is_named
);
788 g_assert(type
== LTTV_GOBJECT
);
789 state_saved_free(self
, *((LttvAttribute
**)value
.v_gobject
));
792 lttv_attribute_remove_by_name(self
->parent
.t_a
, LTTV_STATE_SAVED_STATES
);
797 create_max_time(LttvTraceState
*tcs
)
799 LttvAttributeValue v
;
801 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
803 g_assert(*(v
.v_pointer
) == NULL
);
804 *(v
.v_pointer
) = g_new(LttTime
,1);
805 *((LttTime
*)*(v
.v_pointer
)) = ltt_time_zero
;
810 get_max_time(LttvTraceState
*tcs
)
812 LttvAttributeValue v
;
814 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
816 g_assert(*(v
.v_pointer
) != NULL
);
817 tcs
->max_time_state_recomputed_in_seek
= (LttTime
*)*(v
.v_pointer
);
822 free_max_time(LttvTraceState
*tcs
)
824 LttvAttributeValue v
;
826 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
828 g_free(*(v
.v_pointer
));
829 *(v
.v_pointer
) = NULL
;
833 typedef struct _LttvNameTables
{
834 // FIXME GQuark *eventtype_names;
835 GQuark
*syscall_names
;
840 GQuark
*soft_irq_names
;
845 create_name_tables(LttvTraceState
*tcs
)
849 GQuark f_name
, e_name
;
853 LttvTraceHookByFacility
*thf
;
859 GString
*fe_name
= g_string_new("");
861 LttvNameTables
*name_tables
= g_new(LttvNameTables
, 1);
863 LttvAttributeValue v
;
865 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
867 g_assert(*(v
.v_pointer
) == NULL
);
868 *(v
.v_pointer
) = name_tables
;
869 #if 0 // Use iteration over the facilities_by_name and then list all event
870 // types of each facility
871 nb
= ltt_trace_eventtype_number(tcs
->parent
.t
);
872 name_tables
->eventtype_names
= g_new(GQuark
, nb
);
873 for(i
= 0 ; i
< nb
; i
++) {
874 et
= ltt_trace_eventtype_get(tcs
->parent
.t
, i
);
875 e_name
= ltt_eventtype_name(et
);
876 f_name
= ltt_facility_name(ltt_eventtype_facility(et
));
877 g_string_printf(fe_name
, "%s.%s", f_name
, e_name
);
878 name_tables
->eventtype_names
[i
] = g_quark_from_string(fe_name
->str
);
881 if(!lttv_trace_find_hook(tcs
->parent
.t
,
882 LTT_FACILITY_KERNEL_ARCH
, LTT_EVENT_SYSCALL_ENTRY
,
883 LTT_FIELD_SYSCALL_ID
, 0, 0,
886 thf
= lttv_trace_hook_get_first(&h
);
888 t
= ltt_field_type(thf
->f1
);
889 nb
= ltt_type_element_number(t
);
891 lttv_trace_hook_destroy(&h
);
893 name_tables
->syscall_names
= g_new(GQuark
, nb
);
894 name_tables
->nb_syscalls
= nb
;
896 for(i
= 0 ; i
< nb
; i
++) {
897 name_tables
->syscall_names
[i
] = ltt_enum_string_get(t
, i
);
900 //name_tables->syscall_names = g_new(GQuark, 256);
901 //for(i = 0 ; i < 256 ; i++) {
902 // g_string_printf(fe_name, "syscall %d", i);
903 // name_tables->syscall_names[i] = g_quark_from_string(fe_name->str);
906 name_tables
->syscall_names
= NULL
;
907 name_tables
->nb_syscalls
= 0;
910 if(!lttv_trace_find_hook(tcs
->parent
.t
, LTT_FACILITY_KERNEL
,
911 LTT_EVENT_TRAP_ENTRY
,
912 LTT_FIELD_TRAP_ID
, 0, 0,
915 thf
= lttv_trace_hook_get_first(&h
);
917 t
= ltt_field_type(thf
->f1
);
918 //nb = ltt_type_element_number(t);
920 lttv_trace_hook_destroy(&h
);
923 name_tables->trap_names = g_new(GQuark, nb);
924 for(i = 0 ; i < nb ; i++) {
925 name_tables->trap_names[i] = g_quark_from_string(
926 ltt_enum_string_get(t, i));
929 name_tables
->nb_traps
= 256;
930 name_tables
->trap_names
= g_new(GQuark
, 256);
931 for(i
= 0 ; i
< 256 ; i
++) {
932 g_string_printf(fe_name
, "trap %d", i
);
933 name_tables
->trap_names
[i
] = g_quark_from_string(fe_name
->str
);
936 name_tables
->trap_names
= NULL
;
937 name_tables
->nb_traps
= 0;
940 if(!lttv_trace_find_hook(tcs
->parent
.t
,
941 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_ENTRY
,
942 LTT_FIELD_IRQ_ID
, 0, 0,
945 thf
= lttv_trace_hook_get_first(&h
);
947 t
= ltt_field_type(thf
->f1
);
948 //nb = ltt_type_element_number(t);
950 lttv_trace_hook_destroy(&h
);
953 name_tables->irq_names = g_new(GQuark, nb);
954 for(i = 0 ; i < nb ; i++) {
955 name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
959 name_tables
->irq_names
= g_new(GQuark
, 256);
960 for(i
= 0 ; i
< 256 ; i
++) {
961 g_string_printf(fe_name
, "irq %d", i
);
962 name_tables
->irq_names
[i
] = g_quark_from_string(fe_name
->str
);
965 name_tables
->irq_names
= NULL
;
968 name_tables->soft_irq_names = g_new(GQuark, nb);
969 for(i = 0 ; i < nb ; i++) {
970 name_tables->soft_irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
974 name_tables
->soft_irq_names
= g_new(GQuark
, 256);
975 for(i
= 0 ; i
< 256 ; i
++) {
976 g_string_printf(fe_name
, "softirq %d", i
);
977 name_tables
->soft_irq_names
[i
] = g_quark_from_string(fe_name
->str
);
981 g_string_free(fe_name
, TRUE
);
986 get_name_tables(LttvTraceState
*tcs
)
988 LttvNameTables
*name_tables
;
990 LttvAttributeValue v
;
992 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
994 g_assert(*(v
.v_pointer
) != NULL
);
995 name_tables
= (LttvNameTables
*)*(v
.v_pointer
);
996 //tcs->eventtype_names = name_tables->eventtype_names;
997 tcs
->syscall_names
= name_tables
->syscall_names
;
998 tcs
->nb_syscalls
= name_tables
->nb_syscalls
;
999 tcs
->trap_names
= name_tables
->trap_names
;
1000 tcs
->nb_traps
= name_tables
->nb_traps
;
1001 tcs
->irq_names
= name_tables
->irq_names
;
1002 tcs
->soft_irq_names
= name_tables
->soft_irq_names
;
1007 free_name_tables(LttvTraceState
*tcs
)
1009 LttvNameTables
*name_tables
;
1011 LttvAttributeValue v
;
1013 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
1015 name_tables
= (LttvNameTables
*)*(v
.v_pointer
);
1016 *(v
.v_pointer
) = NULL
;
1018 // g_free(name_tables->eventtype_names);
1019 if(name_tables
->syscall_names
) g_free(name_tables
->syscall_names
);
1020 if(name_tables
->trap_names
) g_free(name_tables
->trap_names
);
1021 if(name_tables
->irq_names
) g_free(name_tables
->irq_names
);
1022 if(name_tables
->soft_irq_names
) g_free(name_tables
->soft_irq_names
);
1023 if(name_tables
) g_free(name_tables
);
1026 #ifdef HASH_TABLE_DEBUG
1028 static void test_process(gpointer key
, gpointer value
, gpointer user_data
)
1030 LttvProcessState
*process
= (LttvProcessState
*)value
;
1032 /* Test for process corruption */
1033 guint stack_len
= process
->execution_stack
->len
;
1036 static void hash_table_check(GHashTable
*table
)
1038 g_hash_table_foreach(table
, test_process
, NULL
);
1045 static void push_state(LttvTracefileState
*tfs
, LttvExecutionMode t
,
1048 LttvExecutionState
*es
;
1050 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
1051 guint cpu
= tfs
->cpu
;
1053 #ifdef HASH_TABLE_DEBUG
1054 hash_table_check(ts
->processes
);
1056 LttvProcessState
*process
= ts
->running_process
[cpu
];
1058 guint depth
= process
->execution_stack
->len
;
1060 process
->execution_stack
=
1061 g_array_set_size(process
->execution_stack
, depth
+ 1);
1064 &g_array_index(process
->execution_stack
, LttvExecutionState
, depth
- 1);
1066 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, depth
);
1069 es
->entry
= es
->change
= tfs
->parent
.timestamp
;
1070 es
->cum_cpu_time
= ltt_time_zero
;
1071 es
->s
= process
->state
->s
;
1072 process
->state
= es
;
1076 * return 1 when empty, else 0 */
1077 int lttv_state_pop_state_cleanup(LttvProcessState
*process
,
1078 LttvTracefileState
*tfs
)
1080 guint cpu
= tfs
->cpu
;
1081 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
1083 guint depth
= process
->execution_stack
->len
;
1089 process
->execution_stack
=
1090 g_array_set_size(process
->execution_stack
, depth
- 1);
1091 process
->state
= &g_array_index(process
->execution_stack
, LttvExecutionState
,
1093 process
->state
->change
= tfs
->parent
.timestamp
;
1098 static void pop_state(LttvTracefileState
*tfs
, LttvExecutionMode t
)
1100 guint cpu
= tfs
->cpu
;
1101 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
1102 LttvProcessState
*process
= ts
->running_process
[cpu
];
1104 guint depth
= process
->execution_stack
->len
;
1106 if(process
->state
->t
!= t
){
1107 g_info("Different execution mode type (%lu.%09lu): ignore it\n",
1108 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
1109 g_info("process state has %s when pop_int is %s\n",
1110 g_quark_to_string(process
->state
->t
),
1111 g_quark_to_string(t
));
1112 g_info("{ %u, %u, %s, %s, %s }\n",
1115 g_quark_to_string(process
->name
),
1116 g_quark_to_string(process
->brand
),
1117 g_quark_to_string(process
->state
->s
));
1122 g_info("Trying to pop last state on stack (%lu.%09lu): ignore it\n",
1123 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
1127 process
->execution_stack
=
1128 g_array_set_size(process
->execution_stack
, depth
- 1);
1129 process
->state
= &g_array_index(process
->execution_stack
, LttvExecutionState
,
1131 process
->state
->change
= tfs
->parent
.timestamp
;
1134 struct search_result
{
1135 const LttTime
*time
; /* Requested time */
1136 LttTime
*best
; /* Best result */
1139 static gint
search_usertrace(gconstpointer a
, gconstpointer b
)
1141 const LttTime
*elem_time
= (const LttTime
*)a
;
1142 /* Explicit non const cast */
1143 struct search_result
*res
= (struct search_result
*)b
;
1145 if(ltt_time_compare(*elem_time
, *(res
->time
)) < 0) {
1146 /* The usertrace was created before the schedchange */
1147 /* Get larger keys */
1149 } else if(ltt_time_compare(*elem_time
, *(res
->time
)) >= 0) {
1150 /* The usertrace was created after the schedchange time */
1151 /* Get smaller keys */
1153 if(ltt_time_compare(*elem_time
, *res
->best
) < 0) {
1154 res
->best
= elem_time
;
1157 res
->best
= elem_time
;
1164 static LttvTracefileState
*ltt_state_usertrace_find(LttvTraceState
*tcs
,
1165 guint pid
, const LttTime
*timestamp
)
1167 LttvTracefileState
*tfs
= NULL
;
1168 struct search_result res
;
1169 /* Find the usertrace associated with a pid and time interval.
1170 * Search in the usertraces by PID (within a hash) and then, for each
1171 * corresponding element of the array, find the first one with creation
1172 * timestamp the lowest, but higher or equal to "timestamp". */
1173 res
.time
= timestamp
;
1175 GTree
*usertrace_tree
= g_hash_table_lookup(tcs
->usertraces
, (gpointer
)pid
);
1176 if(usertrace_tree
) {
1177 g_tree_search(usertrace_tree
, search_usertrace
, &res
);
1179 tfs
= g_tree_lookup(usertrace_tree
, res
.best
);
1187 lttv_state_create_process(LttvTraceState
*tcs
, LttvProcessState
*parent
,
1188 guint cpu
, guint pid
, guint tgid
, GQuark name
, const LttTime
*timestamp
)
1190 LttvProcessState
*process
= g_new(LttvProcessState
, 1);
1192 LttvExecutionState
*es
;
1194 LttvTraceContext
*tc
= (LttvTraceContext
*)tcs
;
1199 process
->tgid
= tgid
;
1201 process
->name
= name
;
1202 process
->brand
= LTTV_STATE_UNBRANDED
;
1203 //process->last_cpu = tfs->cpu_name;
1204 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
1205 process
->type
= LTTV_STATE_USER_THREAD
;
1206 process
->usertrace
= ltt_state_usertrace_find(tcs
, pid
, timestamp
);
1207 process
->current_function
= 0; //function 0x0 by default.
1209 g_info("Process %u, core %p", process
->pid
, process
);
1210 g_hash_table_insert(tcs
->processes
, process
, process
);
1213 process
->ppid
= parent
->pid
;
1214 process
->creation_time
= *timestamp
;
1217 /* No parent. This process exists but we are missing all information about
1218 its creation. The birth time is set to zero but we remember the time of
1223 process
->creation_time
= ltt_time_zero
;
1226 process
->insertion_time
= *timestamp
;
1227 sprintf(buffer
,"%d-%lu.%lu",pid
, process
->creation_time
.tv_sec
,
1228 process
->creation_time
.tv_nsec
);
1229 process
->pid_time
= g_quark_from_string(buffer
);
1231 //process->last_cpu = tfs->cpu_name;
1232 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
1233 process
->execution_stack
= g_array_sized_new(FALSE
, FALSE
,
1234 sizeof(LttvExecutionState
), PREALLOCATED_EXECUTION_STACK
);
1235 process
->execution_stack
= g_array_set_size(process
->execution_stack
, 2);
1236 es
= process
->state
= &g_array_index(process
->execution_stack
,
1237 LttvExecutionState
, 0);
1238 es
->t
= LTTV_STATE_USER_MODE
;
1239 es
->n
= LTTV_STATE_SUBMODE_NONE
;
1240 es
->entry
= *timestamp
;
1241 //g_assert(timestamp->tv_sec != 0);
1242 es
->change
= *timestamp
;
1243 es
->cum_cpu_time
= ltt_time_zero
;
1244 es
->s
= LTTV_STATE_RUN
;
1246 es
= process
->state
= &g_array_index(process
->execution_stack
,
1247 LttvExecutionState
, 1);
1248 es
->t
= LTTV_STATE_SYSCALL
;
1249 es
->n
= LTTV_STATE_SUBMODE_NONE
;
1250 es
->entry
= *timestamp
;
1251 //g_assert(timestamp->tv_sec != 0);
1252 es
->change
= *timestamp
;
1253 es
->cum_cpu_time
= ltt_time_zero
;
1254 es
->s
= LTTV_STATE_WAIT_FORK
;
1256 /* Allocate an empty function call stack. If it's empty, use 0x0. */
1257 process
->user_stack
= g_array_sized_new(FALSE
, FALSE
,
1258 sizeof(guint64
), 0);
1263 LttvProcessState
*lttv_state_find_process(LttvTraceState
*ts
, guint cpu
,
1266 LttvProcessState key
;
1267 LttvProcessState
*process
;
1271 process
= g_hash_table_lookup(ts
->processes
, &key
);
1276 lttv_state_find_process_or_create(LttvTraceState
*ts
, guint cpu
, guint pid
,
1279 LttvProcessState
*process
= lttv_state_find_process(ts
, cpu
, pid
);
1280 LttvExecutionState
*es
;
1282 /* Put ltt_time_zero creation time for unexisting processes */
1283 if(unlikely(process
== NULL
)) {
1284 process
= lttv_state_create_process(ts
,
1285 NULL
, cpu
, pid
, 0, LTTV_STATE_UNNAMED
, timestamp
);
1286 /* We are not sure is it's a kernel thread or normal thread, put the
1287 * bottom stack state to unknown */
1288 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
1289 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
1294 /* FIXME : this function should be called when we receive an event telling that
1295 * release_task has been called in the kernel. In happens generally when
1296 * the parent waits for its child terminaison, but may also happen in special
1297 * cases in the child's exit : when the parent ignores its children SIGCCHLD or
1298 * has the flag SA_NOCLDWAIT. It can also happen when the child is part
1299 * of a killed thread ground, but isn't the leader.
1301 static void exit_process(LttvTracefileState
*tfs
, LttvProcessState
*process
)
1303 LttvTraceState
*ts
= LTTV_TRACE_STATE(tfs
->parent
.t_context
);
1304 LttvProcessState key
;
1306 key
.pid
= process
->pid
;
1307 key
.cpu
= process
->cpu
;
1308 g_hash_table_remove(ts
->processes
, &key
);
1309 g_array_free(process
->execution_stack
, TRUE
);
1310 g_array_free(process
->user_stack
, TRUE
);
1315 static void free_process_state(gpointer key
, gpointer value
,gpointer user_data
)
1317 g_array_free(((LttvProcessState
*)value
)->execution_stack
, TRUE
);
1318 g_array_free(((LttvProcessState
*)value
)->user_stack
, TRUE
);
1323 static void lttv_state_free_process_table(GHashTable
*processes
)
1325 g_hash_table_foreach(processes
, free_process_state
, NULL
);
1326 g_hash_table_destroy(processes
);
1330 static gboolean
syscall_entry(void *hook_data
, void *call_data
)
1332 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1333 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1334 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1335 LttField
*f
= thf
->f1
;
1337 LttvExecutionSubmode submode
;
1339 guint nb_syscalls
= ((LttvTraceState
*)(s
->parent
.t_context
))->nb_syscalls
;
1340 guint syscall
= ltt_event_get_unsigned(e
, f
);
1342 if(syscall
< nb_syscalls
) {
1343 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->syscall_names
[
1346 /* Fixup an incomplete syscall table */
1347 GString
*string
= g_string_new("");
1348 g_string_printf(string
, "syscall %u", syscall
);
1349 submode
= g_quark_from_string(string
->str
);
1350 g_string_free(string
, TRUE
);
1352 push_state(s
, LTTV_STATE_SYSCALL
, submode
);
1357 static gboolean
syscall_exit(void *hook_data
, void *call_data
)
1359 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1361 pop_state(s
, LTTV_STATE_SYSCALL
);
1366 static gboolean
trap_entry(void *hook_data
, void *call_data
)
1368 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1369 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1370 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1371 LttField
*f
= thf
->f1
;
1373 LttvExecutionSubmode submode
;
1375 guint64 nb_traps
= ((LttvTraceState
*)(s
->parent
.t_context
))->nb_traps
;
1376 guint64 trap
= ltt_event_get_long_unsigned(e
, f
);
1378 if(trap
< nb_traps
) {
1379 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->trap_names
[trap
];
1381 /* Fixup an incomplete trap table */
1382 GString
*string
= g_string_new("");
1383 g_string_printf(string
, "trap %llu", trap
);
1384 submode
= g_quark_from_string(string
->str
);
1385 g_string_free(string
, TRUE
);
1388 push_state(s
, LTTV_STATE_TRAP
, submode
);
1393 static gboolean
trap_exit(void *hook_data
, void *call_data
)
1395 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1397 pop_state(s
, LTTV_STATE_TRAP
);
1402 static gboolean
irq_entry(void *hook_data
, void *call_data
)
1404 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1405 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1406 guint8 fac_id
= ltt_event_facility_id(e
);
1407 guint8 ev_id
= ltt_event_eventtype_id(e
);
1408 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1409 // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
1410 g_assert(thf
->f1
!= NULL
);
1411 // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
1412 LttField
*f
= thf
->f1
;
1414 LttvExecutionSubmode submode
;
1416 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->irq_names
[
1417 ltt_event_get_unsigned(e
, f
)];
1419 /* Do something with the info about being in user or system mode when int? */
1420 push_state(s
, LTTV_STATE_IRQ
, submode
);
1424 static gboolean
soft_irq_exit(void *hook_data
, void *call_data
)
1426 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1428 pop_state(s
, LTTV_STATE_SOFT_IRQ
);
1434 static gboolean
irq_exit(void *hook_data
, void *call_data
)
1436 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1438 pop_state(s
, LTTV_STATE_IRQ
);
1442 static gboolean
soft_irq_entry(void *hook_data
, void *call_data
)
1444 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1445 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1446 guint8 fac_id
= ltt_event_facility_id(e
);
1447 guint8 ev_id
= ltt_event_eventtype_id(e
);
1448 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1449 // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
1450 g_assert(thf
->f1
!= NULL
);
1451 // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
1452 LttField
*f
= thf
->f1
;
1454 LttvExecutionSubmode submode
;
1456 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->soft_irq_names
[
1457 ltt_event_get_long_unsigned(e
, f
)];
1459 /* Do something with the info about being in user or system mode when int? */
1460 push_state(s
, LTTV_STATE_SOFT_IRQ
, submode
);
1464 static void push_function(LttvTracefileState
*tfs
, guint64 funcptr
)
1468 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
1469 guint cpu
= tfs
->cpu
;
1470 LttvProcessState
*process
= ts
->running_process
[cpu
];
1472 guint depth
= process
->user_stack
->len
;
1474 process
->user_stack
=
1475 g_array_set_size(process
->user_stack
, depth
+ 1);
1477 new_func
= &g_array_index(process
->user_stack
, guint64
, depth
);
1478 *new_func
= funcptr
;
1479 process
->current_function
= funcptr
;
1482 static void pop_function(LttvTracefileState
*tfs
, guint64 funcptr
)
1484 guint cpu
= tfs
->cpu
;
1485 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
1486 LttvProcessState
*process
= ts
->running_process
[cpu
];
1488 if(process
->current_function
!= funcptr
){
1489 g_info("Different functions (%lu.%09lu): ignore it\n",
1490 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
1491 g_info("process state has %llu when pop_function is %llu\n",
1492 process
->current_function
, funcptr
);
1493 g_info("{ %u, %u, %s, %s, %s }\n",
1496 g_quark_to_string(process
->name
),
1497 g_quark_to_string(process
->brand
),
1498 g_quark_to_string(process
->state
->s
));
1501 guint depth
= process
->user_stack
->len
;
1504 g_info("Trying to pop last function on stack (%lu.%09lu): ignore it\n",
1505 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
1509 process
->user_stack
=
1510 g_array_set_size(process
->user_stack
, depth
- 1);
1511 process
->current_function
=
1512 g_array_index(process
->user_stack
, guint64
, depth
- 2);
1516 static gboolean
function_entry(void *hook_data
, void *call_data
)
1518 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1519 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1520 guint8 fac_id
= ltt_event_facility_id(e
);
1521 guint8 ev_id
= ltt_event_eventtype_id(e
);
1522 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1523 g_assert(thf
->f1
!= NULL
);
1524 LttField
*f
= thf
->f1
;
1525 guint64 funcptr
= ltt_event_get_long_unsigned(e
, f
);
1527 push_function(s
, funcptr
);
1531 static gboolean
function_exit(void *hook_data
, void *call_data
)
1533 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1534 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1535 guint8 fac_id
= ltt_event_facility_id(e
);
1536 guint8 ev_id
= ltt_event_eventtype_id(e
);
1537 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1538 g_assert(thf
->f1
!= NULL
);
1539 LttField
*f
= thf
->f1
;
1540 guint64 funcptr
= ltt_event_get_long_unsigned(e
, f
);
1542 LttvExecutionSubmode submode
;
1544 pop_function(s
, funcptr
);
1548 static gboolean
schedchange(void *hook_data
, void *call_data
)
1550 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1552 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1553 LttvProcessState
*process
= ts
->running_process
[cpu
];
1554 LttvProcessState
*old_process
= ts
->running_process
[cpu
];
1556 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1557 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1558 guint pid_in
, pid_out
;
1561 pid_out
= ltt_event_get_unsigned(e
, thf
->f1
);
1562 pid_in
= ltt_event_get_unsigned(e
, thf
->f2
);
1563 state_out
= ltt_event_get_int(e
, thf
->f3
);
1565 if(likely(process
!= NULL
)) {
1567 /* We could not know but it was not the idle process executing.
1568 This should only happen at the beginning, before the first schedule
1569 event, and when the initial information (current process for each CPU)
1570 is missing. It is not obvious how we could, after the fact, compensate
1571 the wrongly attributed statistics. */
1573 //This test only makes sense once the state is known and if there is no
1574 //missing events. We need to silently ignore schedchange coming after a
1575 //process_free, or it causes glitches. (FIXME)
1576 //if(unlikely(process->pid != pid_out)) {
1577 // g_assert(process->pid == 0);
1580 if(unlikely(process
->state
->s
== LTTV_STATE_EXIT
)) {
1581 process
->state
->s
= LTTV_STATE_ZOMBIE
;
1582 process
->state
->change
= s
->parent
.timestamp
;
1584 if(unlikely(state_out
== 0)) process
->state
->s
= LTTV_STATE_WAIT_CPU
;
1585 else process
->state
->s
= LTTV_STATE_WAIT
;
1586 process
->state
->change
= s
->parent
.timestamp
;
1590 exit_process(s
, process
); /* EXIT_DEAD */
1591 /* see sched.h for states */
1593 process
= ts
->running_process
[cpu
] =
1594 lttv_state_find_process_or_create(
1595 (LttvTraceState
*)s
->parent
.t_context
,
1597 &s
->parent
.timestamp
);
1598 process
->state
->s
= LTTV_STATE_RUN
;
1600 if(process
->usertrace
)
1601 process
->usertrace
->cpu
= cpu
;
1602 // process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)s)->tf);
1603 process
->state
->change
= s
->parent
.timestamp
;
1607 static gboolean
process_fork(void *hook_data
, void *call_data
)
1609 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1610 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1611 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1613 guint child_pid
; /* In the Linux Kernel, there is one PID per thread. */
1614 guint child_tgid
; /* tgid in the Linux kernel is the "real" POSIX PID. */
1615 LttvProcessState
*zombie_process
;
1617 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1618 LttvProcessState
*process
= ts
->running_process
[cpu
];
1619 LttvProcessState
*child_process
;
1622 parent_pid
= ltt_event_get_unsigned(e
, thf
->f1
);
1625 child_pid
= ltt_event_get_unsigned(e
, thf
->f2
);
1628 if(thf
->f3
) child_tgid
= ltt_event_get_unsigned(e
, thf
->f3
);
1629 else child_tgid
= 0;
1631 /* Mathieu : it seems like the process might have been scheduled in before the
1632 * fork, and, in a rare case, might be the current process. This might happen
1633 * in a SMP case where we don't have enough precision on the clocks.
1635 * Test reenabled after precision fixes on time. (Mathieu) */
1637 zombie_process
= lttv_state_find_process(ts
, ANY_CPU
, child_pid
);
1639 if(unlikely(zombie_process
!= NULL
)) {
1640 /* Reutilisation of PID. Only now we are sure that the old PID
1641 * has been released. FIXME : should know when release_task happens instead.
1643 guint num_cpus
= ltt_trace_get_num_cpu(ts
->parent
.t
);
1645 for(i
=0; i
< num_cpus
; i
++) {
1646 g_assert(zombie_process
!= ts
->running_process
[i
]);
1649 exit_process(s
, zombie_process
);
1652 g_assert(process
->pid
!= child_pid
);
1653 // FIXME : Add this test in the "known state" section
1654 // g_assert(process->pid == parent_pid);
1655 child_process
= lttv_state_find_process(ts
, ANY_CPU
, child_pid
);
1656 if(child_process
== NULL
) {
1657 child_process
= lttv_state_create_process(ts
, process
, cpu
,
1658 child_pid
, child_tgid
,
1659 LTTV_STATE_UNNAMED
, &s
->parent
.timestamp
);
1661 /* The process has already been created : due to time imprecision between
1662 * multiple CPUs : it has been scheduled in before creation. Note that we
1663 * shouldn't have this kind of imprecision.
1665 * Simply put a correct parent.
1667 g_assert(0); /* This is a problematic case : the process has been created
1668 before the fork event */
1669 child_process
->ppid
= process
->pid
;
1670 child_process
->tgid
= child_tgid
;
1672 g_assert(child_process
->name
== LTTV_STATE_UNNAMED
);
1673 child_process
->name
= process
->name
;
1674 child_process
->brand
= process
->brand
;
1679 /* We stamp a newly created process as kernel_thread */
1680 static gboolean
process_kernel_thread(void *hook_data
, void *call_data
)
1682 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1683 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1684 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1687 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1688 LttvProcessState
*process
;
1689 LttvExecutionState
*es
;
1692 pid
= ltt_event_get_unsigned(e
, thf
->f1
);
1694 process
= lttv_state_find_process(ts
, ANY_CPU
, pid
);
1695 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
1696 es
->t
= LTTV_STATE_SYSCALL
;
1697 process
->type
= LTTV_STATE_KERNEL_THREAD
;
1702 static gboolean
process_exit(void *hook_data
, void *call_data
)
1704 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1705 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1706 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1710 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1711 LttvProcessState
*process
; // = ts->running_process[cpu];
1713 pid
= ltt_event_get_unsigned(e
, thf
->f1
);
1715 // FIXME : Add this test in the "known state" section
1716 // g_assert(process->pid == pid);
1718 process
= lttv_state_find_process(ts
, ANY_CPU
, pid
);
1719 if(likely(process
!= NULL
)) {
1720 process
->state
->s
= LTTV_STATE_EXIT
;
1725 static gboolean
process_free(void *hook_data
, void *call_data
)
1727 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1728 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1729 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1730 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1732 LttvProcessState
*process
;
1734 /* PID of the process to release */
1735 release_pid
= ltt_event_get_unsigned(e
, thf
->f1
);
1737 g_assert(release_pid
!= 0);
1739 process
= lttv_state_find_process(ts
, ANY_CPU
, release_pid
);
1741 if(likely(process
!= NULL
)) {
1742 /* release_task is happening at kernel level : we can now safely release
1743 * the data structure of the process */
1744 //This test is fun, though, as it may happen that
1745 //at time t : CPU 0 : process_free
1746 //at time t+150ns : CPU 1 : schedule out
1747 //Clearly due to time imprecision, we disable it. (Mathieu)
1748 //If this weird case happen, we have no choice but to put the
1749 //Currently running process on the cpu to 0.
1750 //I re-enable it following time precision fixes. (Mathieu)
1751 //Well, in the case where an process is freed by a process on another CPU
1752 //and still scheduled, it happens that this is the schedchange that will
1753 //drop the last reference count. Do not free it here!
1754 guint num_cpus
= ltt_trace_get_num_cpu(ts
->parent
.t
);
1756 for(i
=0; i
< num_cpus
; i
++) {
1757 //g_assert(process != ts->running_process[i]);
1758 if(process
== ts
->running_process
[i
]) {
1759 //ts->running_process[i] = lttv_state_find_process(ts, i, 0);
1763 if(i
== num_cpus
) /* process is not scheduled */
1764 exit_process(s
, process
);
1771 static gboolean
process_exec(void *hook_data
, void *call_data
)
1773 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1774 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1775 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1776 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1779 LttvProcessState
*process
= ts
->running_process
[cpu
];
1781 /* PID of the process to release */
1782 guint64 name_len
= ltt_event_field_element_number(e
, thf
->f1
);
1783 //name = ltt_event_get_string(e, thf->f1);
1784 LttField
*child
= ltt_event_field_element_select(e
, thf
->f1
, 0);
1786 (gchar
*)(ltt_event_data(e
)+ltt_event_field_offset(e
, child
));
1787 gchar
*null_term_name
= g_new(gchar
, name_len
+1);
1788 memcpy(null_term_name
, name_begin
, name_len
);
1789 null_term_name
[name_len
] = '\0';
1791 process
->name
= g_quark_from_string(null_term_name
);
1792 process
->brand
= LTTV_STATE_UNBRANDED
;
1793 g_free(null_term_name
);
1797 static gboolean
thread_brand(void *hook_data
, void *call_data
)
1799 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1800 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1801 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1802 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1805 LttvProcessState
*process
= ts
->running_process
[cpu
];
1807 name
= ltt_event_get_string(e
, thf
->f1
);
1808 process
->brand
= g_quark_from_string(name
);
1813 static gboolean
enum_process_state(void *hook_data
, void *call_data
)
1815 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1816 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1817 //It's slow : optimise later by doing this before reading trace.
1818 LttEventType
*et
= ltt_event_eventtype(e
);
1820 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1826 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1827 LttvProcessState
*process
= ts
->running_process
[cpu
];
1828 LttvProcessState
*parent_process
;
1829 LttField
*f4
, *f5
, *f6
, *f7
, *f8
;
1830 GQuark type
, mode
, submode
, status
;
1831 LttvExecutionState
*es
;
1834 pid
= ltt_event_get_unsigned(e
, thf
->f1
);
1837 parent_pid
= ltt_event_get_unsigned(e
, thf
->f2
);
1840 command
= ltt_event_get_string(e
, thf
->f3
);
1843 f4
= ltt_eventtype_field_by_name(et
, LTT_FIELD_TYPE
);
1844 type
= ltt_enum_string_get(ltt_field_type(f4
),
1845 ltt_event_get_unsigned(e
, f4
));
1848 f5
= ltt_eventtype_field_by_name(et
, LTT_FIELD_MODE
);
1849 mode
= ltt_enum_string_get(ltt_field_type(f5
),
1850 ltt_event_get_unsigned(e
, f5
));
1853 f6
= ltt_eventtype_field_by_name(et
, LTT_FIELD_SUBMODE
);
1854 submode
= ltt_enum_string_get(ltt_field_type(f6
),
1855 ltt_event_get_unsigned(e
, f6
));
1858 f7
= ltt_eventtype_field_by_name(et
, LTT_FIELD_STATUS
);
1859 status
= ltt_enum_string_get(ltt_field_type(f7
),
1860 ltt_event_get_unsigned(e
, f7
));
1863 f8
= ltt_eventtype_field_by_name(et
, LTT_FIELD_TGID
);
1864 if(f8
) tgid
= ltt_event_get_unsigned(e
, f8
);
1867 /* The process might exist if a process was forked while performing the state
1869 process
= lttv_state_find_process(ts
, ANY_CPU
, pid
);
1870 if(process
== NULL
) {
1871 parent_process
= lttv_state_find_process(ts
, ANY_CPU
, parent_pid
);
1872 process
= lttv_state_create_process(ts
, parent_process
, cpu
,
1873 pid
, tgid
, g_quark_from_string(command
),
1874 &s
->parent
.timestamp
);
1876 /* Keep the stack bottom : a running user mode */
1877 /* Disabled because of inconsistencies in the current statedump states. */
1878 if(type
== LTTV_STATE_KERNEL_THREAD
) {
1879 /* Only keep the bottom */
1880 process
->execution_stack
= g_array_set_size(process
->execution_stack
, 1);
1881 es
= process
->state
= &g_array_index(process
->execution_stack
,
1882 LttvExecutionState
, 0);
1883 es
->t
= LTTV_STATE_SYSCALL
;
1887 /* On top of it : */
1888 es
= process
->state
= &g_array_index(process
->execution_stack
,
1889 LttvExecutionState
, 1);
1890 es
->t
= LTTV_STATE_USER_MODE
;
1897 es
= process
->state
= &g_array_index(process
->execution_stack
,
1898 LttvExecutionState
, 1);
1899 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
1900 es
->s
= LTTV_STATE_UNNAMED
;
1901 es
->n
= LTTV_STATE_SUBMODE_UNKNOWN
;
1905 /* The process has already been created :
1906 * Probably was forked while dumping the process state or
1907 * was simply scheduled in prior to get the state dump event.
1908 * We know for sure if it is a user space thread.
1910 process
->ppid
= parent_pid
;
1911 process
->tgid
= tgid
;
1912 process
->name
= g_quark_from_string(command
);
1913 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
1914 if(type
!= LTTV_STATE_KERNEL_THREAD
)
1915 es
->t
= LTTV_STATE_USER_MODE
;
1916 /* Don't mess around with the stack, it will eventually become
1917 * ok after the end of state dump. */
1923 gint
lttv_state_hook_add_event_hooks(void *hook_data
, void *call_data
)
1925 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
1927 lttv_state_add_event_hooks(tss
);
1932 void lttv_state_add_event_hooks(LttvTracesetState
*self
)
1934 LttvTraceset
*traceset
= self
->parent
.ts
;
1936 guint i
, j
, k
, l
, nb_trace
, nb_tracefile
;
1940 LttvTracefileState
*tfs
;
1944 LttvTraceHookByFacility
*thf
;
1946 LttvTraceHook
*hook
;
1948 LttvAttributeValue val
;
1953 nb_trace
= lttv_traceset_number(traceset
);
1954 for(i
= 0 ; i
< nb_trace
; i
++) {
1955 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
1957 /* Find the eventtype id for the following events and register the
1958 associated by id hooks. */
1960 hooks
= g_array_sized_new(FALSE
, FALSE
, sizeof(LttvTraceHook
), 18);
1961 hooks
= g_array_set_size(hooks
, 18); // Max possible number of hooks.
1964 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1965 LTT_FACILITY_KERNEL_ARCH
, LTT_EVENT_SYSCALL_ENTRY
,
1966 LTT_FIELD_SYSCALL_ID
, 0, 0,
1967 syscall_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
1970 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1971 LTT_FACILITY_KERNEL_ARCH
, LTT_EVENT_SYSCALL_EXIT
,
1973 syscall_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
1976 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1977 LTT_FACILITY_KERNEL
, LTT_EVENT_TRAP_ENTRY
,
1978 LTT_FIELD_TRAP_ID
, 0, 0,
1979 trap_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
1982 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1983 LTT_FACILITY_KERNEL
, LTT_EVENT_TRAP_EXIT
,
1985 trap_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
1988 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1989 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_ENTRY
,
1990 LTT_FIELD_IRQ_ID
, 0, 0,
1991 irq_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
1994 ret
= lttv_trace_find_hook(ts
->parent
.t
,
1995 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_EXIT
,
1997 irq_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2000 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2001 LTT_FACILITY_KERNEL
, LTT_EVENT_SOFT_IRQ_ENTRY
,
2002 LTT_FIELD_SOFT_IRQ_ID
, 0, 0,
2003 soft_irq_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2006 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2007 LTT_FACILITY_KERNEL
, LTT_EVENT_SOFT_IRQ_EXIT
,
2009 soft_irq_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2012 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2013 LTT_FACILITY_PROCESS
, LTT_EVENT_SCHEDCHANGE
,
2014 LTT_FIELD_OUT
, LTT_FIELD_IN
, LTT_FIELD_OUT_STATE
,
2015 schedchange
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2018 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2019 LTT_FACILITY_PROCESS
, LTT_EVENT_FORK
,
2020 LTT_FIELD_PARENT_PID
, LTT_FIELD_CHILD_PID
, LTT_FIELD_TGID
,
2021 process_fork
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2024 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2025 LTT_FACILITY_PROCESS
, LTT_EVENT_KERNEL_THREAD
,
2026 LTT_FIELD_PID
, 0, 0,
2027 process_kernel_thread
, NULL
, &g_array_index(hooks
, LttvTraceHook
,
2031 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2032 LTT_FACILITY_PROCESS
, LTT_EVENT_EXIT
,
2033 LTT_FIELD_PID
, 0, 0,
2034 process_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2037 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2038 LTT_FACILITY_PROCESS
, LTT_EVENT_FREE
,
2039 LTT_FIELD_PID
, 0, 0,
2040 process_free
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2043 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2044 LTT_FACILITY_FS
, LTT_EVENT_EXEC
,
2045 LTT_FIELD_FILENAME
, 0, 0,
2046 process_exec
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2049 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2050 LTT_FACILITY_USER_GENERIC
, LTT_EVENT_THREAD_BRAND
,
2051 LTT_FIELD_NAME
, 0, 0,
2052 thread_brand
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2055 /* statedump-related hooks */
2056 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2057 LTT_FACILITY_STATEDUMP
, LTT_EVENT_ENUM_PROCESS_STATE
,
2058 LTT_FIELD_PID
, LTT_FIELD_PARENT_PID
, LTT_FIELD_NAME
,
2059 enum_process_state
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2062 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2063 LTT_FACILITY_USER_GENERIC
, LTT_EVENT_FUNCTION_ENTRY
,
2064 LTT_FIELD_THIS_FN
, LTT_FIELD_CALL_SITE
, 0,
2065 function_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2068 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2069 LTT_FACILITY_USER_GENERIC
, LTT_EVENT_FUNCTION_EXIT
,
2070 LTT_FIELD_THIS_FN
, LTT_FIELD_CALL_SITE
, 0,
2071 function_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2074 hooks
= g_array_set_size(hooks
, hn
);
2076 /* Add these hooks to each event_by_id hooks list */
2078 nb_tracefile
= ts
->parent
.tracefiles
->len
;
2080 for(j
= 0 ; j
< nb_tracefile
; j
++) {
2082 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
2083 LttvTracefileContext
*, j
));
2085 for(k
= 0 ; k
< hooks
->len
; k
++) {
2086 hook
= &g_array_index(hooks
, LttvTraceHook
, k
);
2087 for(l
=0;l
<hook
->fac_list
->len
;l
++) {
2088 thf
= g_array_index(hook
->fac_list
, LttvTraceHookByFacility
*, l
);
2090 lttv_hooks_by_id_find(tfs
->parent
.event_by_id
, thf
->id
),
2097 lttv_attribute_find(ts
->parent
.a
, LTTV_STATE_HOOKS
, LTTV_POINTER
, &val
);
2098 *(val
.v_pointer
) = hooks
;
2102 gint
lttv_state_hook_remove_event_hooks(void *hook_data
, void *call_data
)
2104 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
2106 lttv_state_remove_event_hooks(tss
);
2111 void lttv_state_remove_event_hooks(LttvTracesetState
*self
)
2113 LttvTraceset
*traceset
= self
->parent
.ts
;
2115 guint i
, j
, k
, l
, nb_trace
, nb_tracefile
;
2119 LttvTracefileState
*tfs
;
2123 LttvTraceHook
*hook
;
2125 LttvTraceHookByFacility
*thf
;
2127 LttvAttributeValue val
;
2129 nb_trace
= lttv_traceset_number(traceset
);
2130 for(i
= 0 ; i
< nb_trace
; i
++) {
2131 ts
= LTTV_TRACE_STATE(self
->parent
.traces
[i
]);
2132 lttv_attribute_find(ts
->parent
.a
, LTTV_STATE_HOOKS
, LTTV_POINTER
, &val
);
2133 hooks
= *(val
.v_pointer
);
2135 /* Remove these hooks from each event_by_id hooks list */
2137 nb_tracefile
= ts
->parent
.tracefiles
->len
;
2139 for(j
= 0 ; j
< nb_tracefile
; j
++) {
2141 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
2142 LttvTracefileContext
*, j
));
2144 for(k
= 0 ; k
< hooks
->len
; k
++) {
2145 hook
= &g_array_index(hooks
, LttvTraceHook
, k
);
2146 for(l
=0;l
<hook
->fac_list
->len
;l
++) {
2147 thf
= g_array_index(hook
->fac_list
, LttvTraceHookByFacility
*, l
);
2149 lttv_hooks_remove_data(
2150 lttv_hooks_by_id_find(tfs
->parent
.event_by_id
, thf
->id
),
2156 for(k
= 0 ; k
< hooks
->len
; k
++)
2157 lttv_trace_hook_destroy(&g_array_index(hooks
, LttvTraceHook
, k
));
2158 g_array_free(hooks
, TRUE
);
2162 static gboolean
state_save_event_hook(void *hook_data
, void *call_data
)
2164 guint
*event_count
= (guint
*)hook_data
;
2166 /* Only save at LTTV_STATE_SAVE_INTERVAL */
2167 if(likely((*event_count
)++ < LTTV_STATE_SAVE_INTERVAL
))
2172 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
2174 LttvTracefileState
*tfcs
;
2176 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
2178 LttEventPosition
*ep
;
2184 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
2186 LttvAttributeValue value
;
2188 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
2189 LTTV_STATE_SAVED_STATES
);
2190 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
2191 value
= lttv_attribute_add(saved_states_tree
,
2192 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
2193 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
2194 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
2195 *(value
.v_time
) = self
->parent
.timestamp
;
2196 lttv_state_save(tcs
, saved_state_tree
);
2197 g_debug("Saving state at time %lu.%lu", self
->parent
.timestamp
.tv_sec
,
2198 self
->parent
.timestamp
.tv_nsec
);
2200 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
2205 static gboolean
state_save_after_trace_hook(void *hook_data
, void *call_data
)
2207 LttvTraceState
*tcs
= (LttvTraceState
*)(call_data
);
2209 *(tcs
->max_time_state_recomputed_in_seek
) = tcs
->parent
.time_span
.end_time
;
2214 guint
lttv_state_current_cpu(LttvTracefileState
*tfs
)
2222 static gboolean
block_start(void *hook_data
, void *call_data
)
2224 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
2226 LttvTracefileState
*tfcs
;
2228 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
2230 LttEventPosition
*ep
;
2232 guint i
, nb_block
, nb_event
, nb_tracefile
;
2236 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
2238 LttvAttributeValue value
;
2240 ep
= ltt_event_position_new();
2242 nb_tracefile
= tcs
->parent
.tracefiles
->len
;
2244 /* Count the number of events added since the last block end in any
2247 for(i
= 0 ; i
< nb_tracefile
; i
++) {
2249 LTTV_TRACEFILE_STATE(&g_array_index(tcs
->parent
.tracefiles
,
2250 LttvTracefileContext
, i
));
2251 ltt_event_position(tfcs
->parent
.e
, ep
);
2252 ltt_event_position_get(ep
, &nb_block
, &nb_event
, &tf
);
2253 tcs
->nb_event
+= nb_event
- tfcs
->saved_position
;
2254 tfcs
->saved_position
= nb_event
;
2258 if(tcs
->nb_event
>= tcs
->save_interval
) {
2259 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
2260 LTTV_STATE_SAVED_STATES
);
2261 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
2262 value
= lttv_attribute_add(saved_states_tree
,
2263 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
2264 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
2265 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
2266 *(value
.v_time
) = self
->parent
.timestamp
;
2267 lttv_state_save(tcs
, saved_state_tree
);
2269 g_debug("Saving state at time %lu.%lu", self
->parent
.timestamp
.tv_sec
,
2270 self
->parent
.timestamp
.tv_nsec
);
2272 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
2278 static gboolean
block_end(void *hook_data
, void *call_data
)
2280 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
2282 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
2286 LttEventPosition
*ep
;
2288 guint nb_block
, nb_event
;
2290 ep
= ltt_event_position_new();
2291 ltt_event_position(self
->parent
.e
, ep
);
2292 ltt_event_position_get(ep
, &nb_block
, &nb_event
, &tf
);
2293 tcs
->nb_event
+= nb_event
- self
->saved_position
+ 1;
2294 self
->saved_position
= 0;
2295 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
2302 void lttv_state_save_add_event_hooks(LttvTracesetState
*self
)
2304 LttvTraceset
*traceset
= self
->parent
.ts
;
2306 guint i
, j
, nb_trace
, nb_tracefile
;
2310 LttvTracefileState
*tfs
;
2312 LttvTraceHook hook_start
, hook_end
;
2314 nb_trace
= lttv_traceset_number(traceset
);
2315 for(i
= 0 ; i
< nb_trace
; i
++) {
2316 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
2318 lttv_trace_find_hook(ts
->parent
.t
, "core","block_start",NULL
,
2319 NULL
, NULL
, block_start
, &hook_start
);
2320 lttv_trace_find_hook(ts
->parent
.t
, "core","block_end",NULL
,
2321 NULL
, NULL
, block_end
, &hook_end
);
2323 nb_tracefile
= ts
->parent
.tracefiles
->len
;
2325 for(j
= 0 ; j
< nb_tracefile
; j
++) {
2327 LTTV_TRACEFILE_STATE(&g_array_index(ts
->parent
.tracefiles
,
2328 LttvTracefileContext
, j
));
2329 lttv_hooks_add(lttv_hooks_by_id_find(tfs
->parent
.event_by_id
,
2330 hook_start
.id
), hook_start
.h
, NULL
, LTTV_PRIO_STATE
);
2331 lttv_hooks_add(lttv_hooks_by_id_find(tfs
->parent
.event_by_id
,
2332 hook_end
.id
), hook_end
.h
, NULL
, LTTV_PRIO_STATE
);
2338 void lttv_state_save_add_event_hooks(LttvTracesetState
*self
)
2340 LttvTraceset
*traceset
= self
->parent
.ts
;
2342 guint i
, j
, nb_trace
, nb_tracefile
;
2346 LttvTracefileState
*tfs
;
2349 nb_trace
= lttv_traceset_number(traceset
);
2350 for(i
= 0 ; i
< nb_trace
; i
++) {
2352 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
2353 nb_tracefile
= ts
->parent
.tracefiles
->len
;
2355 guint
*event_count
= g_new(guint
, 1);
2358 for(j
= 0 ; j
< nb_tracefile
; j
++) {
2360 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
2361 LttvTracefileContext
*, j
));
2362 lttv_hooks_add(tfs
->parent
.event
,
2363 state_save_event_hook
,
2370 lttv_process_traceset_begin(&self
->parent
,
2371 NULL
, NULL
, NULL
, NULL
, NULL
);
2375 gint
lttv_state_save_hook_add_event_hooks(void *hook_data
, void *call_data
)
2377 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
2379 lttv_state_save_add_event_hooks(tss
);
2386 void lttv_state_save_remove_event_hooks(LttvTracesetState
*self
)
2388 LttvTraceset
*traceset
= self
->parent
.ts
;
2390 guint i
, j
, nb_trace
, nb_tracefile
;
2394 LttvTracefileState
*tfs
;
2396 LttvTraceHook hook_start
, hook_end
;
2398 nb_trace
= lttv_traceset_number(traceset
);
2399 for(i
= 0 ; i
< nb_trace
; i
++) {
2400 ts
= LTTV_TRACE_STATE(self
->parent
.traces
[i
]);
2402 lttv_trace_find_hook(ts
->parent
.t
, "core","block_start",NULL
,
2403 NULL
, NULL
, block_start
, &hook_start
);
2405 lttv_trace_find_hook(ts
->parent
.t
, "core","block_end",NULL
,
2406 NULL
, NULL
, block_end
, &hook_end
);
2408 nb_tracefile
= ts
->parent
.tracefiles
->len
;
2410 for(j
= 0 ; j
< nb_tracefile
; j
++) {
2412 LTTV_TRACEFILE_STATE(&g_array_index(ts
->parent
.tracefiles
,
2413 LttvTracefileContext
, j
));
2414 lttv_hooks_remove_data(lttv_hooks_by_id_find(
2415 tfs
->parent
.event_by_id
, hook_start
.id
), hook_start
.h
, NULL
);
2416 lttv_hooks_remove_data(lttv_hooks_by_id_find(
2417 tfs
->parent
.event_by_id
, hook_end
.id
), hook_end
.h
, NULL
);
2423 void lttv_state_save_remove_event_hooks(LttvTracesetState
*self
)
2425 LttvTraceset
*traceset
= self
->parent
.ts
;
2427 guint i
, j
, nb_trace
, nb_tracefile
;
2431 LttvTracefileState
*tfs
;
2433 LttvHooks
*after_trace
= lttv_hooks_new();
2435 lttv_hooks_add(after_trace
,
2436 state_save_after_trace_hook
,
2441 lttv_process_traceset_end(&self
->parent
,
2442 NULL
, after_trace
, NULL
, NULL
, NULL
);
2444 lttv_hooks_destroy(after_trace
);
2446 nb_trace
= lttv_traceset_number(traceset
);
2447 for(i
= 0 ; i
< nb_trace
; i
++) {
2449 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
2450 nb_tracefile
= ts
->parent
.tracefiles
->len
;
2452 guint
*event_count
= NULL
;
2454 for(j
= 0 ; j
< nb_tracefile
; j
++) {
2456 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
2457 LttvTracefileContext
*, j
));
2458 event_count
= lttv_hooks_remove(tfs
->parent
.event
,
2459 state_save_event_hook
);
2461 if(event_count
) g_free(event_count
);
2465 gint
lttv_state_save_hook_remove_event_hooks(void *hook_data
, void *call_data
)
2467 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
2469 lttv_state_save_remove_event_hooks(tss
);
2474 void lttv_state_traceset_seek_time_closest(LttvTracesetState
*self
, LttTime t
)
2476 LttvTraceset
*traceset
= self
->parent
.ts
;
2480 int min_pos
, mid_pos
, max_pos
;
2482 guint call_rest
= 0;
2484 LttvTraceState
*tcs
;
2486 LttvAttributeValue value
;
2488 LttvAttributeType type
;
2490 LttvAttributeName name
;
2494 LttvAttribute
*saved_states_tree
, *saved_state_tree
, *closest_tree
;
2496 //g_tree_destroy(self->parent.pqueue);
2497 //self->parent.pqueue = g_tree_new(compare_tracefile);
2499 g_info("Entering seek_time_closest for time %lu.%lu", t
.tv_sec
, t
.tv_nsec
);
2501 nb_trace
= lttv_traceset_number(traceset
);
2502 for(i
= 0 ; i
< nb_trace
; i
++) {
2503 tcs
= (LttvTraceState
*)self
->parent
.traces
[i
];
2505 if(ltt_time_compare(t
, *(tcs
->max_time_state_recomputed_in_seek
)) < 0) {
2506 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
2507 LTTV_STATE_SAVED_STATES
);
2510 if(saved_states_tree
) {
2511 max_pos
= lttv_attribute_get_number(saved_states_tree
) - 1;
2512 mid_pos
= max_pos
/ 2;
2513 while(min_pos
< max_pos
) {
2514 type
= lttv_attribute_get(saved_states_tree
, mid_pos
, &name
, &value
,
2516 g_assert(type
== LTTV_GOBJECT
);
2517 saved_state_tree
= *((LttvAttribute
**)(value
.v_gobject
));
2518 type
= lttv_attribute_get_by_name(saved_state_tree
, LTTV_STATE_TIME
,
2520 g_assert(type
== LTTV_TIME
);
2521 if(ltt_time_compare(*(value
.v_time
), t
) < 0) {
2523 closest_tree
= saved_state_tree
;
2525 else max_pos
= mid_pos
- 1;
2527 mid_pos
= (min_pos
+ max_pos
+ 1) / 2;
2531 /* restore the closest earlier saved state */
2533 lttv_state_restore(tcs
, closest_tree
);
2537 /* There is no saved state, yet we want to have it. Restart at T0 */
2539 restore_init_state(tcs
);
2540 lttv_process_trace_seek_time(&(tcs
->parent
), ltt_time_zero
);
2543 /* We want to seek quickly without restoring/updating the state */
2545 restore_init_state(tcs
);
2546 lttv_process_trace_seek_time(&(tcs
->parent
), t
);
2549 if(!call_rest
) g_info("NOT Calling restore");
2554 traceset_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
2560 traceset_state_finalize (LttvTracesetState
*self
)
2562 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
2563 finalize(G_OBJECT(self
));
2568 traceset_state_class_init (LttvTracesetContextClass
*klass
)
2570 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
2572 gobject_class
->finalize
= (void (*)(GObject
*self
)) traceset_state_finalize
;
2573 klass
->init
= (void (*)(LttvTracesetContext
*self
, LttvTraceset
*ts
))init
;
2574 klass
->fini
= (void (*)(LttvTracesetContext
*self
))fini
;
2575 klass
->new_traceset_context
= new_traceset_context
;
2576 klass
->new_trace_context
= new_trace_context
;
2577 klass
->new_tracefile_context
= new_tracefile_context
;
2582 lttv_traceset_state_get_type(void)
2584 static GType type
= 0;
2586 static const GTypeInfo info
= {
2587 sizeof (LttvTracesetStateClass
),
2588 NULL
, /* base_init */
2589 NULL
, /* base_finalize */
2590 (GClassInitFunc
) traceset_state_class_init
, /* class_init */
2591 NULL
, /* class_finalize */
2592 NULL
, /* class_data */
2593 sizeof (LttvTracesetState
),
2594 0, /* n_preallocs */
2595 (GInstanceInitFunc
) traceset_state_instance_init
, /* instance_init */
2596 NULL
/* value handling */
2599 type
= g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE
, "LttvTracesetStateType",
2607 trace_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
2613 trace_state_finalize (LttvTraceState
*self
)
2615 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_CONTEXT_TYPE
))->
2616 finalize(G_OBJECT(self
));
2621 trace_state_class_init (LttvTraceStateClass
*klass
)
2623 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
2625 gobject_class
->finalize
= (void (*)(GObject
*self
)) trace_state_finalize
;
2626 klass
->state_save
= state_save
;
2627 klass
->state_restore
= state_restore
;
2628 klass
->state_saved_free
= state_saved_free
;
2633 lttv_trace_state_get_type(void)
2635 static GType type
= 0;
2637 static const GTypeInfo info
= {
2638 sizeof (LttvTraceStateClass
),
2639 NULL
, /* base_init */
2640 NULL
, /* base_finalize */
2641 (GClassInitFunc
) trace_state_class_init
, /* class_init */
2642 NULL
, /* class_finalize */
2643 NULL
, /* class_data */
2644 sizeof (LttvTraceState
),
2645 0, /* n_preallocs */
2646 (GInstanceInitFunc
) trace_state_instance_init
, /* instance_init */
2647 NULL
/* value handling */
2650 type
= g_type_register_static (LTTV_TRACE_CONTEXT_TYPE
,
2651 "LttvTraceStateType", &info
, 0);
2658 tracefile_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
2664 tracefile_state_finalize (LttvTracefileState
*self
)
2666 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_CONTEXT_TYPE
))->
2667 finalize(G_OBJECT(self
));
2672 tracefile_state_class_init (LttvTracefileStateClass
*klass
)
2674 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
2676 gobject_class
->finalize
= (void (*)(GObject
*self
)) tracefile_state_finalize
;
2681 lttv_tracefile_state_get_type(void)
2683 static GType type
= 0;
2685 static const GTypeInfo info
= {
2686 sizeof (LttvTracefileStateClass
),
2687 NULL
, /* base_init */
2688 NULL
, /* base_finalize */
2689 (GClassInitFunc
) tracefile_state_class_init
, /* class_init */
2690 NULL
, /* class_finalize */
2691 NULL
, /* class_data */
2692 sizeof (LttvTracefileState
),
2693 0, /* n_preallocs */
2694 (GInstanceInitFunc
) tracefile_state_instance_init
, /* instance_init */
2695 NULL
/* value handling */
2698 type
= g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE
,
2699 "LttvTracefileStateType", &info
, 0);
2705 static void module_init()
2707 LTTV_STATE_UNNAMED
= g_quark_from_string("UNNAMED");
2708 LTTV_STATE_UNBRANDED
= g_quark_from_string("UNBRANDED");
2709 LTTV_STATE_MODE_UNKNOWN
= g_quark_from_string("MODE_UNKNOWN");
2710 LTTV_STATE_USER_MODE
= g_quark_from_string("USER_MODE");
2711 LTTV_STATE_SYSCALL
= g_quark_from_string("SYSCALL");
2712 LTTV_STATE_TRAP
= g_quark_from_string("TRAP");
2713 LTTV_STATE_IRQ
= g_quark_from_string("IRQ");
2714 LTTV_STATE_SOFT_IRQ
= g_quark_from_string("SOFTIRQ");
2715 LTTV_STATE_SUBMODE_UNKNOWN
= g_quark_from_string("UNKNOWN");
2716 LTTV_STATE_SUBMODE_NONE
= g_quark_from_string("NONE");
2717 LTTV_STATE_WAIT_FORK
= g_quark_from_string("WAIT_FORK");
2718 LTTV_STATE_WAIT_CPU
= g_quark_from_string("WAIT_CPU");
2719 LTTV_STATE_EXIT
= g_quark_from_string("EXIT");
2720 LTTV_STATE_ZOMBIE
= g_quark_from_string("ZOMBIE");
2721 LTTV_STATE_WAIT
= g_quark_from_string("WAIT");
2722 LTTV_STATE_RUN
= g_quark_from_string("RUN");
2723 LTTV_STATE_DEAD
= g_quark_from_string("DEAD");
2724 LTTV_STATE_USER_THREAD
= g_quark_from_string("USER_THREAD");
2725 LTTV_STATE_KERNEL_THREAD
= g_quark_from_string("KERNEL_THREAD");
2726 LTTV_STATE_TRACEFILES
= g_quark_from_string("tracefiles");
2727 LTTV_STATE_PROCESSES
= g_quark_from_string("processes");
2728 LTTV_STATE_PROCESS
= g_quark_from_string("process");
2729 LTTV_STATE_RUNNING_PROCESS
= g_quark_from_string("running_process");
2730 LTTV_STATE_EVENT
= g_quark_from_string("event");
2731 LTTV_STATE_SAVED_STATES
= g_quark_from_string("saved states");
2732 LTTV_STATE_SAVED_STATES_TIME
= g_quark_from_string("saved states time");
2733 LTTV_STATE_TIME
= g_quark_from_string("time");
2734 LTTV_STATE_HOOKS
= g_quark_from_string("saved state hooks");
2735 LTTV_STATE_NAME_TABLES
= g_quark_from_string("name tables");
2736 LTTV_STATE_TRACE_STATE_USE_COUNT
=
2737 g_quark_from_string("trace_state_use_count");
2740 LTT_FACILITY_KERNEL
= g_quark_from_string("kernel");
2741 LTT_FACILITY_KERNEL_ARCH
= g_quark_from_string("kernel_arch");
2742 LTT_FACILITY_PROCESS
= g_quark_from_string("process");
2743 LTT_FACILITY_FS
= g_quark_from_string("fs");
2744 LTT_FACILITY_STATEDUMP
= g_quark_from_string("statedump");
2745 LTT_FACILITY_USER_GENERIC
= g_quark_from_string("user_generic");
2748 LTT_EVENT_SYSCALL_ENTRY
= g_quark_from_string("syscall_entry");
2749 LTT_EVENT_SYSCALL_EXIT
= g_quark_from_string("syscall_exit");
2750 LTT_EVENT_TRAP_ENTRY
= g_quark_from_string("trap_entry");
2751 LTT_EVENT_TRAP_EXIT
= g_quark_from_string("trap_exit");
2752 LTT_EVENT_IRQ_ENTRY
= g_quark_from_string("irq_entry");
2753 LTT_EVENT_IRQ_EXIT
= g_quark_from_string("irq_exit");
2754 LTT_EVENT_SOFT_IRQ_ENTRY
= g_quark_from_string("soft_irq_entry");
2755 LTT_EVENT_SOFT_IRQ_EXIT
= g_quark_from_string("soft_irq_exit");
2756 LTT_EVENT_SCHEDCHANGE
= g_quark_from_string("schedchange");
2757 LTT_EVENT_FORK
= g_quark_from_string("fork");
2758 LTT_EVENT_KERNEL_THREAD
= g_quark_from_string("kernel_thread");
2759 LTT_EVENT_EXIT
= g_quark_from_string("exit");
2760 LTT_EVENT_FREE
= g_quark_from_string("free");
2761 LTT_EVENT_EXEC
= g_quark_from_string("exec");
2762 LTT_EVENT_ENUM_PROCESS_STATE
= g_quark_from_string("enumerate_process_state");
2763 LTT_EVENT_FUNCTION_ENTRY
= g_quark_from_string("function_entry");
2764 LTT_EVENT_FUNCTION_EXIT
= g_quark_from_string("function_exit");
2765 LTT_EVENT_THREAD_BRAND
= g_quark_from_string("thread_brand");
2768 LTT_FIELD_SYSCALL_ID
= g_quark_from_string("syscall_id");
2769 LTT_FIELD_TRAP_ID
= g_quark_from_string("trap_id");
2770 LTT_FIELD_IRQ_ID
= g_quark_from_string("irq_id");
2771 LTT_FIELD_SOFT_IRQ_ID
= g_quark_from_string("softirq_id");
2772 LTT_FIELD_OUT
= g_quark_from_string("out");
2773 LTT_FIELD_IN
= g_quark_from_string("in");
2774 LTT_FIELD_OUT_STATE
= g_quark_from_string("out_state");
2775 LTT_FIELD_PARENT_PID
= g_quark_from_string("parent_pid");
2776 LTT_FIELD_CHILD_PID
= g_quark_from_string("child_pid");
2777 LTT_FIELD_PID
= g_quark_from_string("pid");
2778 LTT_FIELD_TGID
= g_quark_from_string("tgid");
2779 LTT_FIELD_FILENAME
= g_quark_from_string("filename");
2780 LTT_FIELD_NAME
= g_quark_from_string("name");
2781 LTT_FIELD_TYPE
= g_quark_from_string("type");
2782 LTT_FIELD_MODE
= g_quark_from_string("mode");
2783 LTT_FIELD_SUBMODE
= g_quark_from_string("submode");
2784 LTT_FIELD_STATUS
= g_quark_from_string("status");
2785 LTT_FIELD_THIS_FN
= g_quark_from_string("this_fn");
2786 LTT_FIELD_CALL_SITE
= g_quark_from_string("call_site");
2790 static void module_destroy()
2795 LTTV_MODULE("state", "State computation", \
2796 "Update the system state, possibly saving it at intervals", \
2797 module_init
, module_destroy
)