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>
35 * usertrace is there only to be able to update the current CPU of the
36 * usertraces when there is a schedchange. it is a way to link the ProcessState
37 * to the associated usertrace. Link only created upon thread creation.
39 * The cpu id is necessary : it gives us back the current ProcessState when we
40 * are considering data from the usertrace.
43 #define PREALLOCATED_EXECUTION_STACK 10
45 /* Facilities Quarks */
49 LTT_FACILITY_KERNEL_ARCH
,
52 LTT_FACILITY_USER_GENERIC
;
57 LTT_EVENT_SYSCALL_ENTRY
,
58 LTT_EVENT_SYSCALL_EXIT
,
63 LTT_EVENT_SOFT_IRQ_ENTRY
,
64 LTT_EVENT_SOFT_IRQ_EXIT
,
65 LTT_EVENT_SCHED_SCHEDULE
,
66 LTT_EVENT_PROCESS_FORK
,
67 LTT_EVENT_KTHREAD_CREATE
,
68 LTT_EVENT_PROCESS_EXIT
,
69 LTT_EVENT_PROCESS_FREE
,
71 LTT_EVENT_PROCESS_STATE
,
72 LTT_EVENT_STATEDUMP_END
,
73 LTT_EVENT_FUNCTION_ENTRY
,
74 LTT_EVENT_FUNCTION_EXIT
,
75 LTT_EVENT_THREAD_BRAND
;
83 LTT_FIELD_SOFT_IRQ_ID
,
101 LTTV_STATE_MODE_UNKNOWN
,
102 LTTV_STATE_USER_MODE
,
109 LTTV_STATE_SUBMODE_UNKNOWN
,
110 LTTV_STATE_SUBMODE_NONE
;
114 LTTV_STATE_WAIT_FORK
,
123 LTTV_STATE_UNBRANDED
;
126 LTTV_STATE_USER_THREAD
,
127 LTTV_STATE_KERNEL_THREAD
;
130 LTTV_STATE_TRACEFILES
,
131 LTTV_STATE_PROCESSES
,
133 LTTV_STATE_RUNNING_PROCESS
,
135 LTTV_STATE_SAVED_STATES
,
136 LTTV_STATE_SAVED_STATES_TIME
,
139 LTTV_STATE_NAME_TABLES
,
140 LTTV_STATE_TRACE_STATE_USE_COUNT
;
142 static void create_max_time(LttvTraceState
*tcs
);
144 static void get_max_time(LttvTraceState
*tcs
);
146 static void free_max_time(LttvTraceState
*tcs
);
148 static void create_name_tables(LttvTraceState
*tcs
);
150 static void get_name_tables(LttvTraceState
*tcs
);
152 static void free_name_tables(LttvTraceState
*tcs
);
154 static void free_saved_state(LttvTraceState
*tcs
);
156 static void lttv_state_free_process_table(GHashTable
*processes
);
158 static void lttv_trace_states_read_raw(LttvTraceState
*tcs
, FILE *fp
,
159 GPtrArray
*quarktable
);
161 void lttv_state_save(LttvTraceState
*self
, LttvAttribute
*container
)
163 LTTV_TRACE_STATE_GET_CLASS(self
)->state_save(self
, container
);
167 void lttv_state_restore(LttvTraceState
*self
, LttvAttribute
*container
)
169 LTTV_TRACE_STATE_GET_CLASS(self
)->state_restore(self
, container
);
173 void lttv_state_state_saved_free(LttvTraceState
*self
,
174 LttvAttribute
*container
)
176 LTTV_TRACE_STATE_GET_CLASS(self
)->state_saved_free(self
, container
);
180 guint
process_hash(gconstpointer key
)
182 guint pid
= ((const LttvProcessState
*)key
)->pid
;
183 return (pid
>>8 ^ pid
>>4 ^ pid
>>2 ^ pid
) ;
187 /* If the hash table hash function is well distributed,
188 * the process_equal should compare different pid */
189 gboolean
process_equal(gconstpointer a
, gconstpointer b
)
191 const LttvProcessState
*process_a
, *process_b
;
194 process_a
= (const LttvProcessState
*)a
;
195 process_b
= (const LttvProcessState
*)b
;
197 if(likely(process_a
->pid
!= process_b
->pid
)) ret
= FALSE
;
198 else if(likely(process_a
->pid
== 0 &&
199 process_a
->cpu
!= process_b
->cpu
)) ret
= FALSE
;
204 static void delete_usertrace(gpointer key
, gpointer value
, gpointer user_data
)
206 g_tree_destroy((GTree
*)value
);
209 static void lttv_state_free_usertraces(GHashTable
*usertraces
)
211 g_hash_table_foreach(usertraces
, delete_usertrace
, NULL
);
212 g_hash_table_destroy(usertraces
);
218 restore_init_state(LttvTraceState
*self
)
222 LttvTracefileState
*tfcs
;
224 LttTime start_time
, end_time
;
226 /* Free the process tables */
227 if(self
->processes
!= NULL
) lttv_state_free_process_table(self
->processes
);
228 if(self
->usertraces
!= NULL
) lttv_state_free_usertraces(self
->usertraces
);
229 self
->processes
= g_hash_table_new(process_hash
, process_equal
);
230 self
->usertraces
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
233 /* Seek time to beginning */
234 // Mathieu : fix : don't seek traceset here : causes inconsistency in seek
235 // closest. It's the tracecontext job to seek the trace to the beginning
236 // anyway : the init state might be used at the middle of the trace as well...
237 //g_tree_destroy(self->parent.ts_context->pqueue);
238 //self->parent.ts_context->pqueue = g_tree_new(compare_tracefile);
240 ltt_trace_time_span_get(self
->parent
.t
, &start_time
, &end_time
);
242 //lttv_process_trace_seek_time(&self->parent, ltt_time_zero);
244 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
246 /* Put the per cpu running_process to beginning state : process 0. */
247 for(i
=0; i
< nb_cpus
; i
++) {
248 LttvExecutionState
*es
;
249 self
->running_process
[i
] = lttv_state_create_process(self
, NULL
, i
, 0, 0,
250 LTTV_STATE_UNNAMED
, &start_time
);
251 /* We are not sure is it's a kernel thread or normal thread, put the
252 * bottom stack state to unknown */
253 self
->running_process
[i
]->execution_stack
=
254 g_array_set_size(self
->running_process
[i
]->execution_stack
, 1);
255 es
= self
->running_process
[i
]->state
=
256 &g_array_index(self
->running_process
[i
]->execution_stack
,
257 LttvExecutionState
, 0);
258 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
259 es
->s
= LTTV_STATE_UNNAMED
;
261 //self->running_process[i]->state->s = LTTV_STATE_RUN;
262 self
->running_process
[i
]->cpu
= i
;
266 nb_tracefile
= self
->parent
.tracefiles
->len
;
268 for(i
= 0 ; i
< nb_tracefile
; i
++) {
270 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
271 LttvTracefileContext
*, i
));
272 ltt_trace_time_span_get(self
->parent
.t
, &tfcs
->parent
.timestamp
, NULL
);
273 // tfcs->saved_position = 0;
274 tfcs
->process
= lttv_state_create_process(tfcs
, NULL
,0);
275 tfcs
->process
->state
->s
= LTTV_STATE_RUN
;
276 tfcs
->process
->last_cpu
= tfcs
->cpu_name
;
277 tfcs
->process
->last_cpu_index
= ltt_tracefile_num(((LttvTracefileContext
*)tfcs
)->tf
);
282 //static LttTime time_zero = {0,0};
284 static gint
compare_usertraces(gconstpointer a
, gconstpointer b
,
287 const LttTime
*t1
= (const LttTime
*)a
;
288 const LttTime
*t2
= (const LttTime
*)b
;
290 return ltt_time_compare(*t1
, *t2
);
293 static void free_usertrace_key(gpointer data
)
298 #define MAX_STRING_LEN 4096
301 state_load_saved_states(LttvTraceState
*tcs
)
304 GPtrArray
*quarktable
;
309 tcs
->has_precomputed_states
= FALSE
;
313 gchar buf
[MAX_STRING_LEN
];
316 trace_path
= g_quark_to_string(ltt_trace_name(tcs
->parent
.t
));
317 strncpy(path
, trace_path
, PATH_MAX
-1);
318 count
= strnlen(trace_path
, PATH_MAX
-1);
319 // quarktable : open, test
320 strncat(path
, "/precomputed/quarktable", PATH_MAX
-count
-1);
321 fp
= fopen(path
, "r");
323 quarktable
= g_ptr_array_sized_new(4096);
325 /* Index 0 is null */
327 if(hdr
== EOF
) return;
328 g_assert(hdr
== HDR_QUARKS
);
332 if(hdr
== EOF
) break;
333 g_assert(hdr
== HDR_QUARK
);
334 g_ptr_array_set_size(quarktable
, q
+1);
337 fread(&buf
[i
], sizeof(gchar
), 1, fp
);
338 if(buf
[i
] == '\0' || feof(fp
)) break;
341 len
= strnlen(buf
, MAX_STRING_LEN
-1);
342 g_ptr_array_index (quarktable
, q
) = g_new(gchar
, len
+1);
343 strncpy(g_ptr_array_index (quarktable
, q
), buf
, len
+1);
349 // saved_states : open, test
350 strncpy(path
, trace_path
, PATH_MAX
-1);
351 count
= strnlen(trace_path
, PATH_MAX
-1);
352 strncat(path
, "/precomputed/states", PATH_MAX
-count
-1);
353 fp
= fopen(path
, "r");
357 if(hdr
!= HDR_TRACE
) goto end
;
359 lttv_trace_states_read_raw(tcs
, fp
, quarktable
);
361 tcs
->has_precomputed_states
= TRUE
;
366 /* Free the quarktable */
367 for(i
=0; i
<quarktable
->len
; i
++) {
368 string
= g_ptr_array_index (quarktable
, i
);
371 g_ptr_array_free(quarktable
, TRUE
);
376 init(LttvTracesetState
*self
, LttvTraceset
*ts
)
378 guint i
, j
, nb_trace
, nb_tracefile
;
380 LttvTraceContext
*tc
;
384 LttvTracefileState
*tfcs
;
386 LttvAttributeValue v
;
388 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
389 init((LttvTracesetContext
*)self
, ts
);
391 nb_trace
= lttv_traceset_number(ts
);
392 for(i
= 0 ; i
< nb_trace
; i
++) {
393 tc
= self
->parent
.traces
[i
];
394 tcs
= LTTV_TRACE_STATE(tc
);
395 tcs
->save_interval
= LTTV_STATE_SAVE_INTERVAL
;
396 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_TRACE_STATE_USE_COUNT
,
400 if(*(v
.v_uint
) == 1) {
401 create_name_tables(tcs
);
402 create_max_time(tcs
);
404 get_name_tables(tcs
);
407 nb_tracefile
= tc
->tracefiles
->len
;
408 tcs
->processes
= NULL
;
409 tcs
->usertraces
= NULL
;
410 tcs
->running_process
= g_new(LttvProcessState
*,
411 ltt_trace_get_num_cpu(tc
->t
));
412 restore_init_state(tcs
);
413 for(j
= 0 ; j
< nb_tracefile
; j
++) {
415 LTTV_TRACEFILE_STATE(g_array_index(tc
->tracefiles
,
416 LttvTracefileContext
*, j
));
417 tfcs
->tracefile_name
= ltt_tracefile_name(tfcs
->parent
.tf
);
418 tfcs
->cpu
= ltt_tracefile_cpu(tfcs
->parent
.tf
);
419 if(ltt_tracefile_tid(tfcs
->parent
.tf
) != 0) {
420 /* It's a Usertrace */
421 guint tid
= ltt_tracefile_tid(tfcs
->parent
.tf
);
422 GTree
*usertrace_tree
= (GTree
*)g_hash_table_lookup(tcs
->usertraces
,
424 if(!usertrace_tree
) {
425 usertrace_tree
= g_tree_new_full(compare_usertraces
,
426 NULL
, free_usertrace_key
, NULL
);
427 g_hash_table_insert(tcs
->usertraces
,
428 (gpointer
)tid
, usertrace_tree
);
430 LttTime
*timestamp
= g_new(LttTime
, 1);
431 *timestamp
= ltt_interpolate_time_from_tsc(tfcs
->parent
.tf
,
432 ltt_tracefile_creation(tfcs
->parent
.tf
));
433 g_tree_insert(usertrace_tree
, timestamp
, tfcs
);
437 /* See if the trace has saved states */
438 state_load_saved_states(tcs
);
443 fini(LttvTracesetState
*self
)
449 LttvTracefileState
*tfcs
;
451 LttvAttributeValue v
;
453 nb_trace
= lttv_traceset_number(LTTV_TRACESET_CONTEXT(self
)->ts
);
454 for(i
= 0 ; i
< nb_trace
; i
++) {
455 tcs
= (LttvTraceState
*)(LTTV_TRACESET_CONTEXT(self
)->traces
[i
]);
456 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_TRACE_STATE_USE_COUNT
,
459 g_assert(*(v
.v_uint
) != 0);
462 if(*(v
.v_uint
) == 0) {
463 free_name_tables(tcs
);
465 free_saved_state(tcs
);
467 g_free(tcs
->running_process
);
468 tcs
->running_process
= NULL
;
469 lttv_state_free_process_table(tcs
->processes
);
470 lttv_state_free_usertraces(tcs
->usertraces
);
471 tcs
->processes
= NULL
;
472 tcs
->usertraces
= NULL
;
474 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
475 fini((LttvTracesetContext
*)self
);
479 static LttvTracesetContext
*
480 new_traceset_context(LttvTracesetContext
*self
)
482 return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE
, NULL
));
486 static LttvTraceContext
*
487 new_trace_context(LttvTracesetContext
*self
)
489 return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE
, NULL
));
493 static LttvTracefileContext
*
494 new_tracefile_context(LttvTracesetContext
*self
)
496 return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE
, NULL
));
500 /* Write the process state of the trace */
502 static void write_process_state(gpointer key
, gpointer value
,
505 LttvProcessState
*process
;
507 LttvExecutionState
*es
;
509 FILE *fp
= (FILE *)user_data
;
514 process
= (LttvProcessState
*)value
;
516 " <PROCESS CORE=%p PID=%u TGID=%u PPID=%u TYPE=\"%s\" CTIME_S=%lu CTIME_NS=%lu ITIME_S=%lu ITIME_NS=%lu NAME=\"%s\" BRAND=\"%s\" CPU=\"%u\">\n",
517 process
, process
->pid
, process
->tgid
, process
->ppid
,
518 g_quark_to_string(process
->type
),
519 process
->creation_time
.tv_sec
,
520 process
->creation_time
.tv_nsec
,
521 process
->insertion_time
.tv_sec
,
522 process
->insertion_time
.tv_nsec
,
523 g_quark_to_string(process
->name
),
524 g_quark_to_string(process
->brand
),
527 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
528 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
529 fprintf(fp
, " <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
530 g_quark_to_string(es
->t
), g_quark_to_string(es
->n
),
531 es
->entry
.tv_sec
, es
->entry
.tv_nsec
);
532 fprintf(fp
, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
533 es
->change
.tv_sec
, es
->change
.tv_nsec
, g_quark_to_string(es
->s
));
536 for(i
= 0 ; i
< process
->user_stack
->len
; i
++) {
537 address
= &g_array_index(process
->user_stack
, guint64
, i
);
538 fprintf(fp
, " <USER_STACK ADDRESS=\"%llu\"/>\n",
542 if(process
->usertrace
) {
543 fprintf(fp
, " <USERTRACE NAME=\"%s\" CPU=%u\n/>",
544 g_quark_to_string(process
->usertrace
->tracefile_name
),
545 process
->usertrace
->cpu
);
549 fprintf(fp
, " </PROCESS>\n");
553 void lttv_state_write(LttvTraceState
*self
, LttTime t
, FILE *fp
)
555 guint i
, nb_tracefile
, nb_block
, offset
;
558 LttvTracefileState
*tfcs
;
562 LttEventPosition
*ep
;
566 ep
= ltt_event_position_new();
568 fprintf(fp
,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t
.tv_sec
, t
.tv_nsec
);
570 g_hash_table_foreach(self
->processes
, write_process_state
, fp
);
572 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
573 for(i
=0;i
<nb_cpus
;i
++) {
574 fprintf(fp
," <CPU NUM=%u RUNNING_PROCESS=%u>\n",
575 i
, self
->running_process
[i
]->pid
);
578 nb_tracefile
= self
->parent
.tracefiles
->len
;
580 for(i
= 0 ; i
< nb_tracefile
; i
++) {
582 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
583 LttvTracefileContext
*, i
));
584 fprintf(fp
, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
585 tfcs
->parent
.timestamp
.tv_sec
,
586 tfcs
->parent
.timestamp
.tv_nsec
);
587 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
588 if(e
== NULL
) fprintf(fp
,"/>\n");
590 ltt_event_position(e
, ep
);
591 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
592 fprintf(fp
, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block
, offset
,
597 fprintf(fp
,"</PROCESS_STATE>\n");
601 static void write_process_state_raw(gpointer key
, gpointer value
,
604 LttvProcessState
*process
;
606 LttvExecutionState
*es
;
608 FILE *fp
= (FILE *)user_data
;
613 process
= (LttvProcessState
*)value
;
614 fputc(HDR_PROCESS
, fp
);
615 //fwrite(&header, sizeof(header), 1, fp);
616 //fprintf(fp, "%s", g_quark_to_string(process->type));
618 fwrite(&process
->type
, sizeof(process
->type
), 1, fp
);
619 //fprintf(fp, "%s", g_quark_to_string(process->name));
621 fwrite(&process
->name
, sizeof(process
->name
), 1, fp
);
622 //fprintf(fp, "%s", g_quark_to_string(process->brand));
624 fwrite(&process
->brand
, sizeof(process
->brand
), 1, fp
);
625 fwrite(&process
->pid
, sizeof(process
->pid
), 1, fp
);
626 fwrite(&process
->tgid
, sizeof(process
->tgid
), 1, fp
);
627 fwrite(&process
->ppid
, sizeof(process
->ppid
), 1, fp
);
628 fwrite(&process
->cpu
, sizeof(process
->cpu
), 1, fp
);
629 fwrite(&process
->creation_time
, sizeof(process
->creation_time
), 1, fp
);
630 fwrite(&process
->insertion_time
, sizeof(process
->insertion_time
), 1, fp
);
634 " <PROCESS CORE=%p PID=%u TGID=%u PPID=%u TYPE=\"%s\" CTIME_S=%lu CTIME_NS=%lu ITIME_S=%lu ITIME_NS=%lu NAME=\"%s\" BRAND=\"%s\" CPU=\"%u\" PROCESS_TYPE=%u>\n",
635 process
, process
->pid
, process
->tgid
, process
->ppid
,
636 g_quark_to_string(process
->type
),
637 process
->creation_time
.tv_sec
,
638 process
->creation_time
.tv_nsec
,
639 process
->insertion_time
.tv_sec
,
640 process
->insertion_time
.tv_nsec
,
641 g_quark_to_string(process
->name
),
642 g_quark_to_string(process
->brand
),
646 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
647 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
650 //fprintf(fp, "%s", g_quark_to_string(es->t));
652 fwrite(&es
->t
, sizeof(es
->t
), 1, fp
);
653 //fprintf(fp, "%s", g_quark_to_string(es->n));
655 fwrite(&es
->n
, sizeof(es
->n
), 1, fp
);
656 //fprintf(fp, "%s", g_quark_to_string(es->s));
658 fwrite(&es
->s
, sizeof(es
->s
), 1, fp
);
659 fwrite(&es
->entry
, sizeof(es
->entry
), 1, fp
);
660 fwrite(&es
->change
, sizeof(es
->change
), 1, fp
);
661 fwrite(&es
->cum_cpu_time
, sizeof(es
->cum_cpu_time
), 1, fp
);
663 fprintf(fp
, " <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
664 g_quark_to_string(es
->t
), g_quark_to_string(es
->n
),
665 es
->entry
.tv_sec
, es
->entry
.tv_nsec
);
666 fprintf(fp
, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
667 es
->change
.tv_sec
, es
->change
.tv_nsec
, g_quark_to_string(es
->s
));
671 for(i
= 0 ; i
< process
->user_stack
->len
; i
++) {
672 address
= &g_array_index(process
->user_stack
, guint64
, i
);
673 fputc(HDR_USER_STACK
, fp
);
674 fwrite(&address
, sizeof(address
), 1, fp
);
676 fprintf(fp
, " <USER_STACK ADDRESS=\"%llu\"/>\n",
681 if(process
->usertrace
) {
682 fputc(HDR_USERTRACE
, fp
);
683 //fprintf(fp, "%s", g_quark_to_string(process->usertrace->tracefile_name));
685 fwrite(&process
->usertrace
->tracefile_name
,
686 sizeof(process
->usertrace
->tracefile_name
), 1, fp
);
687 fwrite(&process
->usertrace
->cpu
, sizeof(process
->usertrace
->cpu
), 1, fp
);
689 fprintf(fp
, " <USERTRACE NAME=\"%s\" CPU=%u\n/>",
690 g_quark_to_string(process
->usertrace
->tracefile_name
),
691 process
->usertrace
->cpu
);
698 void lttv_state_write_raw(LttvTraceState
*self
, LttTime t
, FILE *fp
)
700 guint i
, nb_tracefile
, nb_block
, offset
;
703 LttvTracefileState
*tfcs
;
707 LttEventPosition
*ep
;
711 ep
= ltt_event_position_new();
713 //fprintf(fp,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t.tv_sec, t.tv_nsec);
714 fputc(HDR_PROCESS_STATE
, fp
);
715 fwrite(&t
, sizeof(t
), 1, fp
);
717 g_hash_table_foreach(self
->processes
, write_process_state_raw
, fp
);
719 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
720 for(i
=0;i
<nb_cpus
;i
++) {
722 fwrite(&i
, sizeof(i
), 1, fp
); /* cpu number */
723 fwrite(&self
->running_process
[i
]->pid
,
724 sizeof(self
->running_process
[i
]->pid
), 1, fp
);
725 //fprintf(fp," <CPU NUM=%u RUNNING_PROCESS=%u>\n",
726 // i, self->running_process[i]->pid);
729 nb_tracefile
= self
->parent
.tracefiles
->len
;
731 for(i
= 0 ; i
< nb_tracefile
; i
++) {
733 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
734 LttvTracefileContext
*, i
));
735 // fprintf(fp, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
736 // tfcs->parent.timestamp.tv_sec,
737 // tfcs->parent.timestamp.tv_nsec);
738 fputc(HDR_TRACEFILE
, fp
);
739 fwrite(&tfcs
->parent
.timestamp
, sizeof(tfcs
->parent
.timestamp
), 1, fp
);
740 /* Note : if timestamp if LTT_TIME_INFINITE, there will be no
741 * position following : end of trace */
742 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
744 ltt_event_position(e
, ep
);
745 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
746 //fprintf(fp, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block, offset,
748 fwrite(&nb_block
, sizeof(nb_block
), 1, fp
);
749 fwrite(&offset
, sizeof(offset
), 1, fp
);
750 fwrite(&tsc
, sizeof(tsc
), 1, fp
);
757 /* Read process state from a file */
759 /* Called because a HDR_PROCESS was found */
760 static void read_process_state_raw(LttvTraceState
*self
, FILE *fp
,
761 GPtrArray
*quarktable
)
763 LttvExecutionState
*es
;
764 LttvProcessState
*process
, *parent_process
;
765 LttvProcessState tmp
;
772 /* TODO : check return value */
773 fread(&tmp
.type
, sizeof(tmp
.type
), 1, fp
);
774 fread(&tmp
.name
, sizeof(tmp
.name
), 1, fp
);
775 fread(&tmp
.brand
, sizeof(tmp
.brand
), 1, fp
);
776 fread(&tmp
.pid
, sizeof(tmp
.pid
), 1, fp
);
777 fread(&tmp
.tgid
, sizeof(tmp
.tgid
), 1, fp
);
778 fread(&tmp
.ppid
, sizeof(tmp
.ppid
), 1, fp
);
779 fread(&tmp
.cpu
, sizeof(tmp
.cpu
), 1, fp
);
780 fread(&tmp
.creation_time
, sizeof(tmp
.creation_time
), 1, fp
);
781 fread(&tmp
.insertion_time
, sizeof(tmp
.insertion_time
), 1, fp
);
784 process
= lttv_state_find_process(self
, tmp
.cpu
, tmp
.pid
);
786 /* We must link to the parent */
787 parent_process
= lttv_state_find_process_or_create(self
, ANY_CPU
, tmp
.ppid
,
789 process
= lttv_state_find_process(self
, ANY_CPU
, tmp
.pid
);
790 if(process
== NULL
) {
791 process
= lttv_state_create_process(self
, parent_process
, tmp
.cpu
,
793 g_quark_from_string((gchar
*)g_ptr_array_index(quarktable
, tmp
.name
)),
797 process
->insertion_time
= tmp
.insertion_time
;
798 process
->creation_time
= tmp
.creation_time
;
799 process
->type
= g_quark_from_string(
800 (gchar
*)g_ptr_array_index(quarktable
, tmp
.type
));
801 process
->tgid
= tmp
.tgid
;
802 process
->ppid
= tmp
.ppid
;
803 process
->brand
= g_quark_from_string(
804 (gchar
*)g_ptr_array_index(quarktable
, tmp
.brand
));
806 g_quark_from_string((gchar
*)g_ptr_array_index(quarktable
, tmp
.name
));
810 if(feof(fp
) || ferror(fp
)) goto end_loop
;
812 gint hdr
= fgetc(fp
);
813 if(hdr
== EOF
) goto end_loop
;
817 process
->execution_stack
=
818 g_array_set_size(process
->execution_stack
,
819 process
->execution_stack
->len
+ 1);
820 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
,
821 process
->execution_stack
->len
-1);
824 fread(&es
->t
, sizeof(es
->t
), 1, fp
);
825 es
->t
= g_quark_from_string(
826 (gchar
*)g_ptr_array_index(quarktable
, es
->t
));
827 fread(&es
->n
, sizeof(es
->n
), 1, fp
);
828 es
->n
= g_quark_from_string(
829 (gchar
*)g_ptr_array_index(quarktable
, es
->n
));
830 fread(&es
->s
, sizeof(es
->s
), 1, fp
);
831 es
->s
= g_quark_from_string(
832 (gchar
*)g_ptr_array_index(quarktable
, es
->s
));
833 fread(&es
->entry
, sizeof(es
->entry
), 1, fp
);
834 fread(&es
->change
, sizeof(es
->change
), 1, fp
);
835 fread(&es
->cum_cpu_time
, sizeof(es
->cum_cpu_time
), 1, fp
);
838 process
->user_stack
= g_array_set_size(process
->user_stack
,
839 process
->user_stack
->len
+ 1);
840 address
= &g_array_index(process
->user_stack
, guint64
,
841 process
->user_stack
->len
-1);
842 fread(address
, sizeof(address
), 1, fp
);
843 process
->current_function
= *address
;
846 fread(&tmpq
, sizeof(tmpq
), 1, fp
);
847 fread(&process
->usertrace
->cpu
, sizeof(process
->usertrace
->cpu
), 1, fp
);
859 /* Called because a HDR_PROCESS_STATE was found */
860 /* Append a saved state to the trace states */
861 void lttv_state_read_raw(LttvTraceState
*self
, FILE *fp
, GPtrArray
*quarktable
)
863 guint i
, nb_tracefile
, nb_block
, offset
;
865 LttvTracefileState
*tfcs
;
867 LttEventPosition
*ep
;
875 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
877 LttvAttributeValue value
;
878 GTree
*pqueue
= self
->parent
.ts_context
->pqueue
;
879 ep
= ltt_event_position_new();
881 restore_init_state(self
);
883 fread(&t
, sizeof(t
), 1, fp
);
886 if(feof(fp
) || ferror(fp
)) goto end_loop
;
888 if(hdr
== EOF
) goto end_loop
;
892 /* Call read_process_state_raw */
893 read_process_state_raw(self
, fp
, quarktable
);
903 case HDR_PROCESS_STATE
:
909 g_error("Error while parsing saved state file : unknown data header %d",
915 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
916 for(i
=0;i
<nb_cpus
;i
++) {
919 g_assert(hdr
== HDR_CPU
);
920 fread(&cpu_num
, sizeof(cpu_num
), 1, fp
); /* cpu number */
921 g_assert(i
== cpu_num
);
922 fread(&self
->running_process
[i
]->pid
,
923 sizeof(self
->running_process
[i
]->pid
), 1, fp
);
926 nb_tracefile
= self
->parent
.tracefiles
->len
;
928 for(i
= 0 ; i
< nb_tracefile
; i
++) {
930 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
931 LttvTracefileContext
*, i
));
932 // fprintf(fp, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
933 // tfcs->parent.timestamp.tv_sec,
934 // tfcs->parent.timestamp.tv_nsec);
935 g_tree_remove(pqueue
, &tfcs
->parent
);
937 g_assert(hdr
== HDR_TRACEFILE
);
938 fread(&tfcs
->parent
.timestamp
, sizeof(tfcs
->parent
.timestamp
), 1, fp
);
939 /* Note : if timestamp if LTT_TIME_INFINITE, there will be no
940 * position following : end of trace */
941 if(ltt_time_compare(tfcs
->parent
.timestamp
, ltt_time_infinite
) != 0) {
942 fread(&nb_block
, sizeof(nb_block
), 1, fp
);
943 fread(&offset
, sizeof(offset
), 1, fp
);
944 fread(&tsc
, sizeof(tsc
), 1, fp
);
945 ltt_event_position_set(ep
, tfcs
->parent
.tf
, nb_block
, offset
, tsc
);
946 gint ret
= ltt_tracefile_seek_position(tfcs
->parent
.tf
, ep
);
948 g_tree_insert(pqueue
, &tfcs
->parent
, &tfcs
->parent
);
953 saved_states_tree
= lttv_attribute_find_subdir(self
->parent
.t_a
,
954 LTTV_STATE_SAVED_STATES
);
955 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
956 value
= lttv_attribute_add(saved_states_tree
,
957 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
958 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
959 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
961 lttv_state_save(self
, saved_state_tree
);
962 g_debug("Saving state at time %lu.%lu", t
.tv_sec
,
965 *(self
->max_time_state_recomputed_in_seek
) = t
;
969 /* Called when a HDR_TRACE is found */
970 void lttv_trace_states_read_raw(LttvTraceState
*tcs
, FILE *fp
,
971 GPtrArray
*quarktable
)
976 if(feof(fp
) || ferror(fp
)) goto end_loop
;
978 if(hdr
== EOF
) goto end_loop
;
981 case HDR_PROCESS_STATE
:
982 /* Call read_process_state_raw */
983 lttv_state_read_raw(tcs
, fp
, quarktable
);
995 g_error("Error while parsing saved state file :"
996 " unexpected data header %d",
1000 g_error("Error while parsing saved state file : unknown data header %d",
1005 *(tcs
->max_time_state_recomputed_in_seek
) = tcs
->parent
.time_span
.end_time
;
1006 restore_init_state(tcs
);
1007 lttv_process_trace_seek_time(tcs
, ltt_time_zero
);
1013 /* Copy each process from an existing hash table to a new one */
1015 static void copy_process_state(gpointer key
, gpointer value
,gpointer user_data
)
1017 LttvProcessState
*process
, *new_process
;
1019 GHashTable
*new_processes
= (GHashTable
*)user_data
;
1023 process
= (LttvProcessState
*)value
;
1024 new_process
= g_new(LttvProcessState
, 1);
1025 *new_process
= *process
;
1026 new_process
->execution_stack
= g_array_sized_new(FALSE
, FALSE
,
1027 sizeof(LttvExecutionState
), PREALLOCATED_EXECUTION_STACK
);
1028 new_process
->execution_stack
=
1029 g_array_set_size(new_process
->execution_stack
,
1030 process
->execution_stack
->len
);
1031 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
1032 g_array_index(new_process
->execution_stack
, LttvExecutionState
, i
) =
1033 g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
1035 new_process
->state
= &g_array_index(new_process
->execution_stack
,
1036 LttvExecutionState
, new_process
->execution_stack
->len
- 1);
1037 new_process
->user_stack
= g_array_sized_new(FALSE
, FALSE
,
1038 sizeof(guint64
), 0);
1039 new_process
->user_stack
=
1040 g_array_set_size(new_process
->user_stack
,
1041 process
->user_stack
->len
);
1042 for(i
= 0 ; i
< process
->user_stack
->len
; i
++) {
1043 g_array_index(new_process
->user_stack
, guint64
, i
) =
1044 g_array_index(process
->user_stack
, guint64
, i
);
1046 new_process
->current_function
= process
->current_function
;
1047 g_hash_table_insert(new_processes
, new_process
, new_process
);
1051 static GHashTable
*lttv_state_copy_process_table(GHashTable
*processes
)
1053 GHashTable
*new_processes
= g_hash_table_new(process_hash
, process_equal
);
1055 g_hash_table_foreach(processes
, copy_process_state
, new_processes
);
1056 return new_processes
;
1060 /* The saved state for each trace contains a member "processes", which
1061 stores a copy of the process table, and a member "tracefiles" with
1062 one entry per tracefile. Each tracefile has a "process" member pointing
1063 to the current process and a "position" member storing the tracefile
1064 position (needed to seek to the current "next" event. */
1066 static void state_save(LttvTraceState
*self
, LttvAttribute
*container
)
1068 guint i
, nb_tracefile
, nb_cpus
;
1070 LttvTracefileState
*tfcs
;
1072 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
1074 guint
*running_process
;
1076 LttvAttributeType type
;
1078 LttvAttributeValue value
;
1080 LttvAttributeName name
;
1082 LttEventPosition
*ep
;
1084 tracefiles_tree
= lttv_attribute_find_subdir(container
,
1085 LTTV_STATE_TRACEFILES
);
1087 value
= lttv_attribute_add(container
, LTTV_STATE_PROCESSES
,
1089 *(value
.v_pointer
) = lttv_state_copy_process_table(self
->processes
);
1091 /* Add the currently running processes array */
1092 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
1093 running_process
= g_new(guint
, nb_cpus
);
1094 for(i
=0;i
<nb_cpus
;i
++) {
1095 running_process
[i
] = self
->running_process
[i
]->pid
;
1097 value
= lttv_attribute_add(container
, LTTV_STATE_RUNNING_PROCESS
,
1099 *(value
.v_pointer
) = running_process
;
1101 g_info("State save");
1103 nb_tracefile
= self
->parent
.tracefiles
->len
;
1105 for(i
= 0 ; i
< nb_tracefile
; i
++) {
1107 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
1108 LttvTracefileContext
*, i
));
1109 tracefile_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
1110 value
= lttv_attribute_add(tracefiles_tree
, i
,
1112 *(value
.v_gobject
) = (GObject
*)tracefile_tree
;
1114 value
= lttv_attribute_add(tracefile_tree
, LTTV_STATE_PROCESS
,
1116 *(value
.v_uint
) = tfcs
->process
->pid
;
1118 value
= lttv_attribute_add(tracefile_tree
, LTTV_STATE_EVENT
,
1120 /* Only save the position if the tfs has not infinite time. */
1121 //if(!g_tree_lookup(self->parent.ts_context->pqueue, &tfcs->parent)
1122 // && current_tfcs != tfcs) {
1123 if(ltt_time_compare(tfcs
->parent
.timestamp
, ltt_time_infinite
) == 0) {
1124 *(value
.v_pointer
) = NULL
;
1126 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
1127 ep
= ltt_event_position_new();
1128 ltt_event_position(e
, ep
);
1129 *(value
.v_pointer
) = ep
;
1131 guint nb_block
, offset
;
1134 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
1135 g_info("Block %u offset %u tsc %llu time %lu.%lu", nb_block
, offset
,
1137 tfcs
->parent
.timestamp
.tv_sec
, tfcs
->parent
.timestamp
.tv_nsec
);
1143 static void state_restore(LttvTraceState
*self
, LttvAttribute
*container
)
1145 guint i
, nb_tracefile
, pid
, nb_cpus
;
1147 LttvTracefileState
*tfcs
;
1149 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
1151 guint
*running_process
;
1153 LttvAttributeType type
;
1155 LttvAttributeValue value
;
1157 LttvAttributeName name
;
1161 LttEventPosition
*ep
;
1163 LttvTracesetContext
*tsc
= self
->parent
.ts_context
;
1165 tracefiles_tree
= lttv_attribute_find_subdir(container
,
1166 LTTV_STATE_TRACEFILES
);
1168 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_PROCESSES
,
1170 g_assert(type
== LTTV_POINTER
);
1171 lttv_state_free_process_table(self
->processes
);
1172 self
->processes
= lttv_state_copy_process_table(*(value
.v_pointer
));
1174 /* Add the currently running processes array */
1175 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
1176 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RUNNING_PROCESS
,
1178 g_assert(type
== LTTV_POINTER
);
1179 running_process
= *(value
.v_pointer
);
1180 for(i
=0;i
<nb_cpus
;i
++) {
1181 pid
= running_process
[i
];
1182 self
->running_process
[i
] = lttv_state_find_process(self
, i
, pid
);
1183 g_assert(self
->running_process
[i
] != NULL
);
1187 nb_tracefile
= self
->parent
.tracefiles
->len
;
1189 //g_tree_destroy(tsc->pqueue);
1190 //tsc->pqueue = g_tree_new(compare_tracefile);
1192 for(i
= 0 ; i
< nb_tracefile
; i
++) {
1194 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
1195 LttvTracefileContext
*, i
));
1196 type
= lttv_attribute_get(tracefiles_tree
, i
, &name
, &value
, &is_named
);
1197 g_assert(type
== LTTV_GOBJECT
);
1198 tracefile_tree
= *((LttvAttribute
**)(value
.v_gobject
));
1200 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_PROCESS
,
1202 g_assert(type
== LTTV_UINT
);
1203 pid
= *(value
.v_uint
);
1204 tfcs
->process
= lttv_state_find_process_or_create(tfcs
, pid
);
1206 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_EVENT
,
1208 g_assert(type
== LTTV_POINTER
);
1209 //g_assert(*(value.v_pointer) != NULL);
1210 ep
= *(value
.v_pointer
);
1211 g_assert(tfcs
->parent
.t_context
!= NULL
);
1213 LttvTracefileContext
*tfc
= LTTV_TRACEFILE_CONTEXT(tfcs
);
1214 g_tree_remove(tsc
->pqueue
, tfc
);
1217 g_assert(ltt_tracefile_seek_position(tfc
->tf
, ep
) == 0);
1218 tfc
->timestamp
= ltt_event_time(ltt_tracefile_get_event(tfc
->tf
));
1219 g_assert(ltt_time_compare(tfc
->timestamp
, ltt_time_infinite
) != 0);
1220 g_tree_insert(tsc
->pqueue
, tfc
, tfc
);
1221 g_info("Restoring state for a tf at time %lu.%lu", tfc
->timestamp
.tv_sec
, tfc
->timestamp
.tv_nsec
);
1223 tfc
->timestamp
= ltt_time_infinite
;
1229 static void state_saved_free(LttvTraceState
*self
, LttvAttribute
*container
)
1231 guint i
, nb_tracefile
, nb_cpus
;
1233 LttvTracefileState
*tfcs
;
1235 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
1237 guint
*running_process
;
1239 LttvAttributeType type
;
1241 LttvAttributeValue value
;
1243 LttvAttributeName name
;
1247 LttEventPosition
*ep
;
1249 tracefiles_tree
= lttv_attribute_find_subdir(container
,
1250 LTTV_STATE_TRACEFILES
);
1251 g_object_ref(G_OBJECT(tracefiles_tree
));
1252 lttv_attribute_remove_by_name(container
, LTTV_STATE_TRACEFILES
);
1254 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_PROCESSES
,
1256 g_assert(type
== LTTV_POINTER
);
1257 lttv_state_free_process_table(*(value
.v_pointer
));
1258 *(value
.v_pointer
) = NULL
;
1259 lttv_attribute_remove_by_name(container
, LTTV_STATE_PROCESSES
);
1261 /* Free running processes array */
1262 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
1263 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RUNNING_PROCESS
,
1265 g_assert(type
== LTTV_POINTER
);
1266 running_process
= *(value
.v_pointer
);
1267 g_free(running_process
);
1269 nb_tracefile
= self
->parent
.tracefiles
->len
;
1271 for(i
= 0 ; i
< nb_tracefile
; i
++) {
1273 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
1274 LttvTracefileContext
*, i
));
1275 type
= lttv_attribute_get(tracefiles_tree
, i
, &name
, &value
, &is_named
);
1276 g_assert(type
== LTTV_GOBJECT
);
1277 tracefile_tree
= *((LttvAttribute
**)(value
.v_gobject
));
1279 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_EVENT
,
1281 g_assert(type
== LTTV_POINTER
);
1282 if(*(value
.v_pointer
) != NULL
) g_free(*(value
.v_pointer
));
1284 g_object_unref(G_OBJECT(tracefiles_tree
));
1288 static void free_saved_state(LttvTraceState
*self
)
1292 LttvAttributeType type
;
1294 LttvAttributeValue value
;
1296 LttvAttributeName name
;
1300 LttvAttribute
*saved_states
;
1302 saved_states
= lttv_attribute_find_subdir(self
->parent
.t_a
,
1303 LTTV_STATE_SAVED_STATES
);
1305 nb
= lttv_attribute_get_number(saved_states
);
1306 for(i
= 0 ; i
< nb
; i
++) {
1307 type
= lttv_attribute_get(saved_states
, i
, &name
, &value
, &is_named
);
1308 g_assert(type
== LTTV_GOBJECT
);
1309 state_saved_free(self
, *((LttvAttribute
**)value
.v_gobject
));
1312 lttv_attribute_remove_by_name(self
->parent
.t_a
, LTTV_STATE_SAVED_STATES
);
1317 create_max_time(LttvTraceState
*tcs
)
1319 LttvAttributeValue v
;
1321 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
1323 g_assert(*(v
.v_pointer
) == NULL
);
1324 *(v
.v_pointer
) = g_new(LttTime
,1);
1325 *((LttTime
*)*(v
.v_pointer
)) = ltt_time_zero
;
1330 get_max_time(LttvTraceState
*tcs
)
1332 LttvAttributeValue v
;
1334 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
1336 g_assert(*(v
.v_pointer
) != NULL
);
1337 tcs
->max_time_state_recomputed_in_seek
= (LttTime
*)*(v
.v_pointer
);
1342 free_max_time(LttvTraceState
*tcs
)
1344 LttvAttributeValue v
;
1346 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
1348 g_free(*(v
.v_pointer
));
1349 *(v
.v_pointer
) = NULL
;
1353 typedef struct _LttvNameTables
{
1354 // FIXME GQuark *eventtype_names;
1355 GQuark
*syscall_names
;
1361 GQuark
*soft_irq_names
;
1367 create_name_tables(LttvTraceState
*tcs
)
1371 GQuark f_name
, e_name
;
1375 LttvTraceHookByFacility
*thf
;
1381 GString
*fe_name
= g_string_new("");
1383 LttvNameTables
*name_tables
= g_new(LttvNameTables
, 1);
1385 LttvAttributeValue v
;
1387 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
1389 g_assert(*(v
.v_pointer
) == NULL
);
1390 *(v
.v_pointer
) = name_tables
;
1391 #if 0 // Use iteration over the facilities_by_name and then list all event
1392 // types of each facility
1393 nb
= ltt_trace_eventtype_number(tcs
->parent
.t
);
1394 name_tables
->eventtype_names
= g_new(GQuark
, nb
);
1395 for(i
= 0 ; i
< nb
; i
++) {
1396 et
= ltt_trace_eventtype_get(tcs
->parent
.t
, i
);
1397 e_name
= ltt_eventtype_name(et
);
1398 f_name
= ltt_facility_name(ltt_eventtype_facility(et
));
1399 g_string_printf(fe_name
, "%s.%s", f_name
, e_name
);
1400 name_tables
->eventtype_names
[i
] = g_quark_from_string(fe_name
->str
);
1403 if(!lttv_trace_find_hook(tcs
->parent
.t
,
1404 LTT_FACILITY_KERNEL_ARCH
, LTT_EVENT_SYSCALL_ENTRY
,
1405 LTT_FIELD_SYSCALL_ID
, 0, 0,
1408 thf
= lttv_trace_hook_get_first(&h
);
1410 t
= ltt_field_type(thf
->f1
);
1411 nb
= ltt_type_element_number(t
);
1413 lttv_trace_hook_destroy(&h
);
1415 name_tables
->syscall_names
= g_new(GQuark
, nb
);
1416 name_tables
->nb_syscalls
= nb
;
1418 for(i
= 0 ; i
< nb
; i
++) {
1419 name_tables
->syscall_names
[i
] = ltt_enum_string_get(t
, i
);
1420 if(!name_tables
->syscall_names
[i
]) {
1421 GString
*string
= g_string_new("");
1422 g_string_printf(string
, "syscall %u", i
);
1423 name_tables
->syscall_names
[i
] = g_quark_from_string(string
->str
);
1424 g_string_free(string
, TRUE
);
1428 //name_tables->syscall_names = g_new(GQuark, 256);
1429 //for(i = 0 ; i < 256 ; i++) {
1430 // g_string_printf(fe_name, "syscall %d", i);
1431 // name_tables->syscall_names[i] = g_quark_from_string(fe_name->str);
1434 name_tables
->syscall_names
= NULL
;
1435 name_tables
->nb_syscalls
= 0;
1438 if(!lttv_trace_find_hook(tcs
->parent
.t
, LTT_FACILITY_KERNEL_ARCH
,
1439 LTT_EVENT_TRAP_ENTRY
,
1440 LTT_FIELD_TRAP_ID
, 0, 0,
1443 thf
= lttv_trace_hook_get_first(&h
);
1445 t
= ltt_field_type(thf
->f1
);
1446 //nb = ltt_type_element_number(t);
1448 lttv_trace_hook_destroy(&h
);
1451 name_tables->trap_names = g_new(GQuark, nb);
1452 for(i = 0 ; i < nb ; i++) {
1453 name_tables->trap_names[i] = g_quark_from_string(
1454 ltt_enum_string_get(t, i));
1457 name_tables
->nb_traps
= 256;
1458 name_tables
->trap_names
= g_new(GQuark
, 256);
1459 for(i
= 0 ; i
< 256 ; i
++) {
1460 g_string_printf(fe_name
, "trap %d", i
);
1461 name_tables
->trap_names
[i
] = g_quark_from_string(fe_name
->str
);
1464 name_tables
->trap_names
= NULL
;
1465 name_tables
->nb_traps
= 0;
1468 if(!lttv_trace_find_hook(tcs
->parent
.t
,
1469 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_ENTRY
,
1470 LTT_FIELD_IRQ_ID
, 0, 0,
1473 thf
= lttv_trace_hook_get_first(&h
);
1475 t
= ltt_field_type(thf
->f1
);
1476 //nb = ltt_type_element_number(t);
1478 lttv_trace_hook_destroy(&h
);
1481 name_tables->irq_names = g_new(GQuark, nb);
1482 for(i = 0 ; i < nb ; i++) {
1483 name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
1487 name_tables
->nb_irqs
= 256;
1488 name_tables
->irq_names
= g_new(GQuark
, 256);
1489 for(i
= 0 ; i
< 256 ; i
++) {
1490 g_string_printf(fe_name
, "irq %d", i
);
1491 name_tables
->irq_names
[i
] = g_quark_from_string(fe_name
->str
);
1494 name_tables
->nb_irqs
= 0;
1495 name_tables
->irq_names
= NULL
;
1498 name_tables->soft_irq_names = g_new(GQuark, nb);
1499 for(i = 0 ; i < nb ; i++) {
1500 name_tables->soft_irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
1504 name_tables
->nb_softirqs
= 256;
1505 name_tables
->soft_irq_names
= g_new(GQuark
, 256);
1506 for(i
= 0 ; i
< 256 ; i
++) {
1507 g_string_printf(fe_name
, "softirq %d", i
);
1508 name_tables
->soft_irq_names
[i
] = g_quark_from_string(fe_name
->str
);
1512 g_string_free(fe_name
, TRUE
);
1517 get_name_tables(LttvTraceState
*tcs
)
1519 LttvNameTables
*name_tables
;
1521 LttvAttributeValue v
;
1523 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
1525 g_assert(*(v
.v_pointer
) != NULL
);
1526 name_tables
= (LttvNameTables
*)*(v
.v_pointer
);
1527 //tcs->eventtype_names = name_tables->eventtype_names;
1528 tcs
->syscall_names
= name_tables
->syscall_names
;
1529 tcs
->nb_syscalls
= name_tables
->nb_syscalls
;
1530 tcs
->trap_names
= name_tables
->trap_names
;
1531 tcs
->nb_traps
= name_tables
->nb_traps
;
1532 tcs
->irq_names
= name_tables
->irq_names
;
1533 tcs
->soft_irq_names
= name_tables
->soft_irq_names
;
1534 tcs
->nb_irqs
= name_tables
->nb_irqs
;
1535 tcs
->nb_softirqs
= name_tables
->nb_softirqs
;
1540 free_name_tables(LttvTraceState
*tcs
)
1542 LttvNameTables
*name_tables
;
1544 LttvAttributeValue v
;
1546 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
1548 name_tables
= (LttvNameTables
*)*(v
.v_pointer
);
1549 *(v
.v_pointer
) = NULL
;
1551 // g_free(name_tables->eventtype_names);
1552 if(name_tables
->syscall_names
) g_free(name_tables
->syscall_names
);
1553 if(name_tables
->trap_names
) g_free(name_tables
->trap_names
);
1554 if(name_tables
->irq_names
) g_free(name_tables
->irq_names
);
1555 if(name_tables
->soft_irq_names
) g_free(name_tables
->soft_irq_names
);
1556 if(name_tables
) g_free(name_tables
);
1559 #ifdef HASH_TABLE_DEBUG
1561 static void test_process(gpointer key
, gpointer value
, gpointer user_data
)
1563 LttvProcessState
*process
= (LttvProcessState
*)value
;
1565 /* Test for process corruption */
1566 guint stack_len
= process
->execution_stack
->len
;
1569 static void hash_table_check(GHashTable
*table
)
1571 g_hash_table_foreach(table
, test_process
, NULL
);
1578 static void push_state(LttvTracefileState
*tfs
, LttvExecutionMode t
,
1581 LttvExecutionState
*es
;
1583 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
1584 guint cpu
= tfs
->cpu
;
1586 #ifdef HASH_TABLE_DEBUG
1587 hash_table_check(ts
->processes
);
1589 LttvProcessState
*process
= ts
->running_process
[cpu
];
1591 guint depth
= process
->execution_stack
->len
;
1593 process
->execution_stack
=
1594 g_array_set_size(process
->execution_stack
, depth
+ 1);
1597 &g_array_index(process
->execution_stack
, LttvExecutionState
, depth
- 1);
1599 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, depth
);
1602 es
->entry
= es
->change
= tfs
->parent
.timestamp
;
1603 es
->cum_cpu_time
= ltt_time_zero
;
1604 es
->s
= process
->state
->s
;
1605 process
->state
= es
;
1609 * return 1 when empty, else 0 */
1610 int lttv_state_pop_state_cleanup(LttvProcessState
*process
,
1611 LttvTracefileState
*tfs
)
1613 guint cpu
= tfs
->cpu
;
1614 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
1616 guint depth
= process
->execution_stack
->len
;
1622 process
->execution_stack
=
1623 g_array_set_size(process
->execution_stack
, depth
- 1);
1624 process
->state
= &g_array_index(process
->execution_stack
, LttvExecutionState
,
1626 process
->state
->change
= tfs
->parent
.timestamp
;
1631 static void pop_state(LttvTracefileState
*tfs
, LttvExecutionMode t
)
1633 guint cpu
= tfs
->cpu
;
1634 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
1635 LttvProcessState
*process
= ts
->running_process
[cpu
];
1637 guint depth
= process
->execution_stack
->len
;
1639 if(process
->state
->t
!= t
){
1640 g_info("Different execution mode type (%lu.%09lu): ignore it\n",
1641 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
1642 g_info("process state has %s when pop_int is %s\n",
1643 g_quark_to_string(process
->state
->t
),
1644 g_quark_to_string(t
));
1645 g_info("{ %u, %u, %s, %s, %s }\n",
1648 g_quark_to_string(process
->name
),
1649 g_quark_to_string(process
->brand
),
1650 g_quark_to_string(process
->state
->s
));
1655 g_info("Trying to pop last state on stack (%lu.%09lu): ignore it\n",
1656 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
1660 process
->execution_stack
=
1661 g_array_set_size(process
->execution_stack
, depth
- 1);
1662 process
->state
= &g_array_index(process
->execution_stack
, LttvExecutionState
,
1664 process
->state
->change
= tfs
->parent
.timestamp
;
1667 struct search_result
{
1668 const LttTime
*time
; /* Requested time */
1669 LttTime
*best
; /* Best result */
1672 static gint
search_usertrace(gconstpointer a
, gconstpointer b
)
1674 const LttTime
*elem_time
= (const LttTime
*)a
;
1675 /* Explicit non const cast */
1676 struct search_result
*res
= (struct search_result
*)b
;
1678 if(ltt_time_compare(*elem_time
, *(res
->time
)) < 0) {
1679 /* The usertrace was created before the schedchange */
1680 /* Get larger keys */
1682 } else if(ltt_time_compare(*elem_time
, *(res
->time
)) >= 0) {
1683 /* The usertrace was created after the schedchange time */
1684 /* Get smaller keys */
1686 if(ltt_time_compare(*elem_time
, *res
->best
) < 0) {
1687 res
->best
= elem_time
;
1690 res
->best
= elem_time
;
1697 static LttvTracefileState
*ltt_state_usertrace_find(LttvTraceState
*tcs
,
1698 guint pid
, const LttTime
*timestamp
)
1700 LttvTracefileState
*tfs
= NULL
;
1701 struct search_result res
;
1702 /* Find the usertrace associated with a pid and time interval.
1703 * Search in the usertraces by PID (within a hash) and then, for each
1704 * corresponding element of the array, find the first one with creation
1705 * timestamp the lowest, but higher or equal to "timestamp". */
1706 res
.time
= timestamp
;
1708 GTree
*usertrace_tree
= g_hash_table_lookup(tcs
->usertraces
, (gpointer
)pid
);
1709 if(usertrace_tree
) {
1710 g_tree_search(usertrace_tree
, search_usertrace
, &res
);
1712 tfs
= g_tree_lookup(usertrace_tree
, res
.best
);
1720 lttv_state_create_process(LttvTraceState
*tcs
, LttvProcessState
*parent
,
1721 guint cpu
, guint pid
, guint tgid
, GQuark name
, const LttTime
*timestamp
)
1723 LttvProcessState
*process
= g_new(LttvProcessState
, 1);
1725 LttvExecutionState
*es
;
1727 LttvTraceContext
*tc
= (LttvTraceContext
*)tcs
;
1732 process
->tgid
= tgid
;
1734 process
->name
= name
;
1735 process
->brand
= LTTV_STATE_UNBRANDED
;
1736 //process->last_cpu = tfs->cpu_name;
1737 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
1738 process
->type
= LTTV_STATE_USER_THREAD
;
1739 process
->usertrace
= ltt_state_usertrace_find(tcs
, pid
, timestamp
);
1740 process
->current_function
= 0; //function 0x0 by default.
1742 g_info("Process %u, core %p", process
->pid
, process
);
1743 g_hash_table_insert(tcs
->processes
, process
, process
);
1746 process
->ppid
= parent
->pid
;
1747 process
->creation_time
= *timestamp
;
1750 /* No parent. This process exists but we are missing all information about
1751 its creation. The birth time is set to zero but we remember the time of
1756 process
->creation_time
= ltt_time_zero
;
1759 process
->insertion_time
= *timestamp
;
1760 sprintf(buffer
,"%d-%lu.%lu",pid
, process
->creation_time
.tv_sec
,
1761 process
->creation_time
.tv_nsec
);
1762 process
->pid_time
= g_quark_from_string(buffer
);
1764 //process->last_cpu = tfs->cpu_name;
1765 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
1766 process
->execution_stack
= g_array_sized_new(FALSE
, FALSE
,
1767 sizeof(LttvExecutionState
), PREALLOCATED_EXECUTION_STACK
);
1768 process
->execution_stack
= g_array_set_size(process
->execution_stack
, 2);
1769 es
= process
->state
= &g_array_index(process
->execution_stack
,
1770 LttvExecutionState
, 0);
1771 es
->t
= LTTV_STATE_USER_MODE
;
1772 es
->n
= LTTV_STATE_SUBMODE_NONE
;
1773 es
->entry
= *timestamp
;
1774 //g_assert(timestamp->tv_sec != 0);
1775 es
->change
= *timestamp
;
1776 es
->cum_cpu_time
= ltt_time_zero
;
1777 es
->s
= LTTV_STATE_RUN
;
1779 es
= process
->state
= &g_array_index(process
->execution_stack
,
1780 LttvExecutionState
, 1);
1781 es
->t
= LTTV_STATE_SYSCALL
;
1782 es
->n
= LTTV_STATE_SUBMODE_NONE
;
1783 es
->entry
= *timestamp
;
1784 //g_assert(timestamp->tv_sec != 0);
1785 es
->change
= *timestamp
;
1786 es
->cum_cpu_time
= ltt_time_zero
;
1787 es
->s
= LTTV_STATE_WAIT_FORK
;
1789 /* Allocate an empty function call stack. If it's empty, use 0x0. */
1790 process
->user_stack
= g_array_sized_new(FALSE
, FALSE
,
1791 sizeof(guint64
), 0);
1796 LttvProcessState
*lttv_state_find_process(LttvTraceState
*ts
, guint cpu
,
1799 LttvProcessState key
;
1800 LttvProcessState
*process
;
1804 process
= g_hash_table_lookup(ts
->processes
, &key
);
1809 lttv_state_find_process_or_create(LttvTraceState
*ts
, guint cpu
, guint pid
,
1810 const LttTime
*timestamp
)
1812 LttvProcessState
*process
= lttv_state_find_process(ts
, cpu
, pid
);
1813 LttvExecutionState
*es
;
1815 /* Put ltt_time_zero creation time for unexisting processes */
1816 if(unlikely(process
== NULL
)) {
1817 process
= lttv_state_create_process(ts
,
1818 NULL
, cpu
, pid
, 0, LTTV_STATE_UNNAMED
, timestamp
);
1819 /* We are not sure is it's a kernel thread or normal thread, put the
1820 * bottom stack state to unknown */
1821 process
->execution_stack
=
1822 g_array_set_size(process
->execution_stack
, 1);
1823 process
->state
= es
=
1824 &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
1825 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
1826 es
->s
= LTTV_STATE_UNNAMED
;
1831 /* FIXME : this function should be called when we receive an event telling that
1832 * release_task has been called in the kernel. In happens generally when
1833 * the parent waits for its child terminaison, but may also happen in special
1834 * cases in the child's exit : when the parent ignores its children SIGCCHLD or
1835 * has the flag SA_NOCLDWAIT. It can also happen when the child is part
1836 * of a killed thread ground, but isn't the leader.
1838 static void exit_process(LttvTracefileState
*tfs
, LttvProcessState
*process
)
1840 LttvTraceState
*ts
= LTTV_TRACE_STATE(tfs
->parent
.t_context
);
1841 LttvProcessState key
;
1843 key
.pid
= process
->pid
;
1844 key
.cpu
= process
->cpu
;
1845 g_hash_table_remove(ts
->processes
, &key
);
1846 g_array_free(process
->execution_stack
, TRUE
);
1847 g_array_free(process
->user_stack
, TRUE
);
1852 static void free_process_state(gpointer key
, gpointer value
,gpointer user_data
)
1854 g_array_free(((LttvProcessState
*)value
)->execution_stack
, TRUE
);
1855 g_array_free(((LttvProcessState
*)value
)->user_stack
, TRUE
);
1860 static void lttv_state_free_process_table(GHashTable
*processes
)
1862 g_hash_table_foreach(processes
, free_process_state
, NULL
);
1863 g_hash_table_destroy(processes
);
1867 static gboolean
syscall_entry(void *hook_data
, void *call_data
)
1869 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1871 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1872 LttvProcessState
*process
= ts
->running_process
[cpu
];
1873 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1874 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1875 LttField
*f
= thf
->f1
;
1877 LttvExecutionSubmode submode
;
1879 guint nb_syscalls
= ((LttvTraceState
*)(s
->parent
.t_context
))->nb_syscalls
;
1880 guint syscall
= ltt_event_get_unsigned(e
, f
);
1882 if(syscall
< nb_syscalls
) {
1883 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->syscall_names
[
1886 /* Fixup an incomplete syscall table */
1887 GString
*string
= g_string_new("");
1888 g_string_printf(string
, "syscall %u", syscall
);
1889 submode
= g_quark_from_string(string
->str
);
1890 g_string_free(string
, TRUE
);
1892 /* There can be no system call from PID 0 : unknown state */
1893 if(process
->pid
!= 0)
1894 push_state(s
, LTTV_STATE_SYSCALL
, submode
);
1899 static gboolean
syscall_exit(void *hook_data
, void *call_data
)
1901 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1903 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1904 LttvProcessState
*process
= ts
->running_process
[cpu
];
1906 /* There can be no system call from PID 0 : unknown state */
1907 if(process
->pid
!= 0)
1908 pop_state(s
, LTTV_STATE_SYSCALL
);
1913 static gboolean
trap_entry(void *hook_data
, void *call_data
)
1915 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1916 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1917 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1918 LttField
*f
= thf
->f1
;
1920 LttvExecutionSubmode submode
;
1922 guint64 nb_traps
= ((LttvTraceState
*)(s
->parent
.t_context
))->nb_traps
;
1923 guint64 trap
= ltt_event_get_long_unsigned(e
, f
);
1925 if(trap
< nb_traps
) {
1926 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->trap_names
[trap
];
1928 /* Fixup an incomplete trap table */
1929 GString
*string
= g_string_new("");
1930 g_string_printf(string
, "trap %llu", trap
);
1931 submode
= g_quark_from_string(string
->str
);
1932 g_string_free(string
, TRUE
);
1935 push_state(s
, LTTV_STATE_TRAP
, submode
);
1940 static gboolean
trap_exit(void *hook_data
, void *call_data
)
1942 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1944 pop_state(s
, LTTV_STATE_TRAP
);
1949 static gboolean
irq_entry(void *hook_data
, void *call_data
)
1951 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1952 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1953 guint8 fac_id
= ltt_event_facility_id(e
);
1954 guint8 ev_id
= ltt_event_eventtype_id(e
);
1955 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1956 // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
1957 g_assert(thf
->f1
!= NULL
);
1958 // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
1959 LttField
*f
= thf
->f1
;
1961 LttvExecutionSubmode submode
;
1962 guint64 irq
= ltt_event_get_long_unsigned(e
, f
);
1963 guint64 nb_irqs
= ((LttvTraceState
*)(s
->parent
.t_context
))->nb_irqs
;
1967 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->irq_names
[irq
];
1969 /* Fixup an incomplete irq table */
1970 GString
*string
= g_string_new("");
1971 g_string_printf(string
, "irq %llu", irq
);
1972 submode
= g_quark_from_string(string
->str
);
1973 g_string_free(string
, TRUE
);
1976 /* Do something with the info about being in user or system mode when int? */
1977 push_state(s
, LTTV_STATE_IRQ
, submode
);
1981 static gboolean
soft_irq_exit(void *hook_data
, void *call_data
)
1983 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1985 pop_state(s
, LTTV_STATE_SOFT_IRQ
);
1991 static gboolean
irq_exit(void *hook_data
, void *call_data
)
1993 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1995 pop_state(s
, LTTV_STATE_IRQ
);
1999 static gboolean
soft_irq_entry(void *hook_data
, void *call_data
)
2001 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2002 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2003 guint8 fac_id
= ltt_event_facility_id(e
);
2004 guint8 ev_id
= ltt_event_eventtype_id(e
);
2005 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2006 // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
2007 g_assert(thf
->f1
!= NULL
);
2008 // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
2009 LttField
*f
= thf
->f1
;
2011 LttvExecutionSubmode submode
;
2012 guint64 softirq
= ltt_event_get_long_unsigned(e
, f
);
2013 guint64 nb_softirqs
= ((LttvTraceState
*)(s
->parent
.t_context
))->nb_softirqs
;
2016 if(softirq
< nb_softirqs
) {
2017 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->soft_irq_names
[softirq
];
2019 /* Fixup an incomplete irq table */
2020 GString
*string
= g_string_new("");
2021 g_string_printf(string
, "softirq %llu", softirq
);
2022 submode
= g_quark_from_string(string
->str
);
2023 g_string_free(string
, TRUE
);
2026 /* Do something with the info about being in user or system mode when int? */
2027 push_state(s
, LTTV_STATE_SOFT_IRQ
, submode
);
2031 static void push_function(LttvTracefileState
*tfs
, guint64 funcptr
)
2035 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
2036 guint cpu
= tfs
->cpu
;
2037 LttvProcessState
*process
= ts
->running_process
[cpu
];
2039 guint depth
= process
->user_stack
->len
;
2041 process
->user_stack
=
2042 g_array_set_size(process
->user_stack
, depth
+ 1);
2044 new_func
= &g_array_index(process
->user_stack
, guint64
, depth
);
2045 *new_func
= funcptr
;
2046 process
->current_function
= funcptr
;
2049 static void pop_function(LttvTracefileState
*tfs
, guint64 funcptr
)
2051 guint cpu
= tfs
->cpu
;
2052 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
2053 LttvProcessState
*process
= ts
->running_process
[cpu
];
2055 if(process
->current_function
!= funcptr
){
2056 g_info("Different functions (%lu.%09lu): ignore it\n",
2057 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
2058 g_info("process state has %llu when pop_function is %llu\n",
2059 process
->current_function
, funcptr
);
2060 g_info("{ %u, %u, %s, %s, %s }\n",
2063 g_quark_to_string(process
->name
),
2064 g_quark_to_string(process
->brand
),
2065 g_quark_to_string(process
->state
->s
));
2068 guint depth
= process
->user_stack
->len
;
2071 g_info("Trying to pop last function on stack (%lu.%09lu): ignore it\n",
2072 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
2076 process
->user_stack
=
2077 g_array_set_size(process
->user_stack
, depth
- 1);
2078 process
->current_function
=
2079 g_array_index(process
->user_stack
, guint64
, depth
- 2);
2083 static gboolean
function_entry(void *hook_data
, void *call_data
)
2085 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2086 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2087 guint8 fac_id
= ltt_event_facility_id(e
);
2088 guint8 ev_id
= ltt_event_eventtype_id(e
);
2089 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2090 g_assert(thf
->f1
!= NULL
);
2091 LttField
*f
= thf
->f1
;
2092 guint64 funcptr
= ltt_event_get_long_unsigned(e
, f
);
2094 push_function(s
, funcptr
);
2098 static gboolean
function_exit(void *hook_data
, void *call_data
)
2100 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2101 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2102 guint8 fac_id
= ltt_event_facility_id(e
);
2103 guint8 ev_id
= ltt_event_eventtype_id(e
);
2104 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2105 g_assert(thf
->f1
!= NULL
);
2106 LttField
*f
= thf
->f1
;
2107 guint64 funcptr
= ltt_event_get_long_unsigned(e
, f
);
2109 LttvExecutionSubmode submode
;
2111 pop_function(s
, funcptr
);
2115 static gboolean
schedchange(void *hook_data
, void *call_data
)
2117 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2119 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2120 LttvProcessState
*process
= ts
->running_process
[cpu
];
2121 LttvProcessState
*old_process
= ts
->running_process
[cpu
];
2123 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2124 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2125 guint pid_in
, pid_out
;
2128 pid_out
= ltt_event_get_unsigned(e
, thf
->f1
);
2129 pid_in
= ltt_event_get_unsigned(e
, thf
->f2
);
2130 state_out
= ltt_event_get_int(e
, thf
->f3
);
2132 if(likely(process
!= NULL
)) {
2134 /* We could not know but it was not the idle process executing.
2135 This should only happen at the beginning, before the first schedule
2136 event, and when the initial information (current process for each CPU)
2137 is missing. It is not obvious how we could, after the fact, compensate
2138 the wrongly attributed statistics. */
2140 //This test only makes sense once the state is known and if there is no
2141 //missing events. We need to silently ignore schedchange coming after a
2142 //process_free, or it causes glitches. (FIXME)
2143 //if(unlikely(process->pid != pid_out)) {
2144 // g_assert(process->pid == 0);
2146 if(process
->pid
== 0
2147 && process
->state
->t
== LTTV_STATE_MODE_UNKNOWN
) {
2149 /* Scheduling out of pid 0 at beginning of the trace :
2150 * we know for sure it is in syscall mode at this point. */
2151 g_assert(process
->execution_stack
->len
== 1);
2152 process
->state
->t
= LTTV_STATE_SYSCALL
;
2153 process
->state
->s
= LTTV_STATE_WAIT
;
2154 process
->state
->change
= s
->parent
.timestamp
;
2155 process
->state
->entry
= s
->parent
.timestamp
;
2158 if(unlikely(process
->state
->s
== LTTV_STATE_EXIT
)) {
2159 process
->state
->s
= LTTV_STATE_ZOMBIE
;
2160 process
->state
->change
= s
->parent
.timestamp
;
2162 if(unlikely(state_out
== 0)) process
->state
->s
= LTTV_STATE_WAIT_CPU
;
2163 else process
->state
->s
= LTTV_STATE_WAIT
;
2164 process
->state
->change
= s
->parent
.timestamp
;
2167 if(state_out
== 32 || state_out
== 128)
2168 exit_process(s
, process
); /* EXIT_DEAD || TASK_DEAD */
2169 /* see sched.h for states */
2172 process
= ts
->running_process
[cpu
] =
2173 lttv_state_find_process_or_create(
2174 (LttvTraceState
*)s
->parent
.t_context
,
2176 &s
->parent
.timestamp
);
2177 process
->state
->s
= LTTV_STATE_RUN
;
2179 if(process
->usertrace
)
2180 process
->usertrace
->cpu
= cpu
;
2181 // process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)s)->tf);
2182 process
->state
->change
= s
->parent
.timestamp
;
2186 static gboolean
process_fork(void *hook_data
, void *call_data
)
2188 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2189 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2190 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2192 guint child_pid
; /* In the Linux Kernel, there is one PID per thread. */
2193 guint child_tgid
; /* tgid in the Linux kernel is the "real" POSIX PID. */
2194 LttvProcessState
*zombie_process
;
2196 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2197 LttvProcessState
*process
= ts
->running_process
[cpu
];
2198 LttvProcessState
*child_process
;
2201 parent_pid
= ltt_event_get_unsigned(e
, thf
->f1
);
2204 child_pid
= ltt_event_get_unsigned(e
, thf
->f2
);
2205 s
->parent
.target_pid
= child_pid
;
2208 if(thf
->f3
) child_tgid
= ltt_event_get_unsigned(e
, thf
->f3
);
2209 else child_tgid
= 0;
2211 /* Mathieu : it seems like the process might have been scheduled in before the
2212 * fork, and, in a rare case, might be the current process. This might happen
2213 * in a SMP case where we don't have enough precision on the clocks.
2215 * Test reenabled after precision fixes on time. (Mathieu) */
2217 zombie_process
= lttv_state_find_process(ts
, ANY_CPU
, child_pid
);
2219 if(unlikely(zombie_process
!= NULL
)) {
2220 /* Reutilisation of PID. Only now we are sure that the old PID
2221 * has been released. FIXME : should know when release_task happens instead.
2223 guint num_cpus
= ltt_trace_get_num_cpu(ts
->parent
.t
);
2225 for(i
=0; i
< num_cpus
; i
++) {
2226 g_assert(zombie_process
!= ts
->running_process
[i
]);
2229 exit_process(s
, zombie_process
);
2232 g_assert(process
->pid
!= child_pid
);
2233 // FIXME : Add this test in the "known state" section
2234 // g_assert(process->pid == parent_pid);
2235 child_process
= lttv_state_find_process(ts
, ANY_CPU
, child_pid
);
2236 if(child_process
== NULL
) {
2237 child_process
= lttv_state_create_process(ts
, process
, cpu
,
2238 child_pid
, child_tgid
,
2239 LTTV_STATE_UNNAMED
, &s
->parent
.timestamp
);
2241 /* The process has already been created : due to time imprecision between
2242 * multiple CPUs : it has been scheduled in before creation. Note that we
2243 * shouldn't have this kind of imprecision.
2245 * Simply put a correct parent.
2247 g_assert(0); /* This is a problematic case : the process has been created
2248 before the fork event */
2249 child_process
->ppid
= process
->pid
;
2250 child_process
->tgid
= child_tgid
;
2252 g_assert(child_process
->name
== LTTV_STATE_UNNAMED
);
2253 child_process
->name
= process
->name
;
2254 child_process
->brand
= process
->brand
;
2259 /* We stamp a newly created process as kernel_thread.
2260 * The thread should not be running yet. */
2261 static gboolean
process_kernel_thread(void *hook_data
, void *call_data
)
2263 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2264 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2265 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2268 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2269 LttvProcessState
*process
;
2270 LttvExecutionState
*es
;
2273 pid
= ltt_event_get_unsigned(e
, thf
->f1
);
2274 s
->parent
.target_pid
= pid
;
2276 process
= lttv_state_find_process(ts
, ANY_CPU
, pid
);
2277 process
->execution_stack
=
2278 g_array_set_size(process
->execution_stack
, 1);
2279 es
= process
->state
=
2280 &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
2281 es
->t
= LTTV_STATE_SYSCALL
;
2282 process
->type
= LTTV_STATE_KERNEL_THREAD
;
2287 static gboolean
process_exit(void *hook_data
, void *call_data
)
2289 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2290 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2291 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2295 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2296 LttvProcessState
*process
; // = ts->running_process[cpu];
2298 pid
= ltt_event_get_unsigned(e
, thf
->f1
);
2299 s
->parent
.target_pid
= pid
;
2301 // FIXME : Add this test in the "known state" section
2302 // g_assert(process->pid == pid);
2304 process
= lttv_state_find_process(ts
, ANY_CPU
, pid
);
2305 if(likely(process
!= NULL
)) {
2306 process
->state
->s
= LTTV_STATE_EXIT
;
2311 static gboolean
process_free(void *hook_data
, void *call_data
)
2313 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2314 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2315 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2316 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2318 LttvProcessState
*process
;
2320 /* PID of the process to release */
2321 release_pid
= ltt_event_get_unsigned(e
, thf
->f1
);
2322 s
->parent
.target_pid
= release_pid
;
2324 g_assert(release_pid
!= 0);
2326 process
= lttv_state_find_process(ts
, ANY_CPU
, release_pid
);
2328 if(likely(process
!= NULL
)) {
2329 /* release_task is happening at kernel level : we can now safely release
2330 * the data structure of the process */
2331 //This test is fun, though, as it may happen that
2332 //at time t : CPU 0 : process_free
2333 //at time t+150ns : CPU 1 : schedule out
2334 //Clearly due to time imprecision, we disable it. (Mathieu)
2335 //If this weird case happen, we have no choice but to put the
2336 //Currently running process on the cpu to 0.
2337 //I re-enable it following time precision fixes. (Mathieu)
2338 //Well, in the case where an process is freed by a process on another CPU
2339 //and still scheduled, it happens that this is the schedchange that will
2340 //drop the last reference count. Do not free it here!
2341 guint num_cpus
= ltt_trace_get_num_cpu(ts
->parent
.t
);
2343 for(i
=0; i
< num_cpus
; i
++) {
2344 //g_assert(process != ts->running_process[i]);
2345 if(process
== ts
->running_process
[i
]) {
2346 //ts->running_process[i] = lttv_state_find_process(ts, i, 0);
2350 if(i
== num_cpus
) /* process is not scheduled */
2351 exit_process(s
, process
);
2358 static gboolean
process_exec(void *hook_data
, void *call_data
)
2360 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2361 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2362 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2363 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2366 LttvProcessState
*process
= ts
->running_process
[cpu
];
2368 /* PID of the process to release */
2369 guint64 name_len
= ltt_event_field_element_number(e
, thf
->f1
);
2370 //name = ltt_event_get_string(e, thf->f1);
2371 LttField
*child
= ltt_event_field_element_select(e
, thf
->f1
, 0);
2373 (gchar
*)(ltt_event_data(e
)+ltt_event_field_offset(e
, child
));
2374 gchar
*null_term_name
= g_new(gchar
, name_len
+1);
2375 memcpy(null_term_name
, name_begin
, name_len
);
2376 null_term_name
[name_len
] = '\0';
2378 process
->name
= g_quark_from_string(null_term_name
);
2379 process
->brand
= LTTV_STATE_UNBRANDED
;
2380 g_free(null_term_name
);
2384 static gboolean
thread_brand(void *hook_data
, void *call_data
)
2386 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2387 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2388 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2389 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2392 LttvProcessState
*process
= ts
->running_process
[cpu
];
2394 name
= ltt_event_get_string(e
, thf
->f1
);
2395 process
->brand
= g_quark_from_string(name
);
2400 static void fix_process(gpointer key
, gpointer value
,
2403 LttvProcessState
*process
;
2404 LttvExecutionState
*es
;
2405 process
= (LttvProcessState
*)value
;
2406 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)user_data
;
2407 LttTime
*timestamp
= (LttTime
*)user_data
;
2409 if(process
->type
== LTTV_STATE_KERNEL_THREAD
) {
2410 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
2411 if(es
->t
== LTTV_STATE_MODE_UNKNOWN
) {
2412 es
->t
= LTTV_STATE_SYSCALL
;
2413 es
->n
= LTTV_STATE_SUBMODE_NONE
;
2414 es
->entry
= *timestamp
;
2415 es
->change
= *timestamp
;
2416 es
->cum_cpu_time
= ltt_time_zero
;
2417 if(es
->s
== LTTV_STATE_UNNAMED
)
2418 es
->s
= LTTV_STATE_WAIT
;
2421 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
2422 if(es
->t
== LTTV_STATE_MODE_UNKNOWN
) {
2423 es
->t
= LTTV_STATE_USER_MODE
;
2424 es
->n
= LTTV_STATE_SUBMODE_NONE
;
2425 es
->entry
= *timestamp
;
2426 //g_assert(timestamp->tv_sec != 0);
2427 es
->change
= *timestamp
;
2428 es
->cum_cpu_time
= ltt_time_zero
;
2429 if(es
->s
== LTTV_STATE_UNNAMED
)
2430 es
->s
= LTTV_STATE_RUN
;
2432 if(process
->execution_stack
->len
== 1) {
2433 /* Still in bottom unknown mode, means never did a system call
2434 * May be either in user mode, syscall mode, running or waiting.*/
2435 /* FIXME : we may be tagging syscall mode when being user mode */
2436 process
->execution_stack
=
2437 g_array_set_size(process
->execution_stack
, 2);
2438 es
= process
->state
= &g_array_index(process
->execution_stack
,
2439 LttvExecutionState
, 1);
2440 es
->t
= LTTV_STATE_SYSCALL
;
2441 es
->n
= LTTV_STATE_SUBMODE_NONE
;
2442 es
->entry
= *timestamp
;
2443 //g_assert(timestamp->tv_sec != 0);
2444 es
->change
= *timestamp
;
2445 es
->cum_cpu_time
= ltt_time_zero
;
2446 if(es
->s
== LTTV_STATE_WAIT_FORK
)
2447 es
->s
= LTTV_STATE_WAIT
;
2453 static gboolean
statedump_end(void *hook_data
, void *call_data
)
2455 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2456 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2457 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
2458 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2459 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2461 /* For all processes */
2462 /* if kernel thread, if stack[0] is unknown, set to syscall mode, wait */
2463 /* else, if stack[0] is unknown, set to user mode, running */
2465 g_hash_table_foreach(ts
->processes
, fix_process
, &tfc
->timestamp
);
2468 static gboolean
enum_process_state(void *hook_data
, void *call_data
)
2470 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2471 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2472 //It's slow : optimise later by doing this before reading trace.
2473 LttEventType
*et
= ltt_event_eventtype(e
);
2475 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2481 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2482 LttvProcessState
*process
= ts
->running_process
[cpu
];
2483 LttvProcessState
*parent_process
;
2484 LttField
*f4
, *f5
, *f6
, *f7
, *f8
;
2485 GQuark type
, mode
, submode
, status
;
2486 LttvExecutionState
*es
;
2490 pid
= ltt_event_get_unsigned(e
, thf
->f1
);
2491 s
->parent
.target_pid
= pid
;
2494 parent_pid
= ltt_event_get_unsigned(e
, thf
->f2
);
2497 command
= ltt_event_get_string(e
, thf
->f3
);
2500 f4
= ltt_eventtype_field_by_name(et
, LTT_FIELD_TYPE
);
2501 type
= ltt_enum_string_get(ltt_field_type(f4
),
2502 ltt_event_get_unsigned(e
, f4
));
2505 f5
= ltt_eventtype_field_by_name(et
, LTT_FIELD_MODE
);
2506 mode
= ltt_enum_string_get(ltt_field_type(f5
),
2507 ltt_event_get_unsigned(e
, f5
));
2510 f6
= ltt_eventtype_field_by_name(et
, LTT_FIELD_SUBMODE
);
2511 submode
= ltt_enum_string_get(ltt_field_type(f6
),
2512 ltt_event_get_unsigned(e
, f6
));
2515 f7
= ltt_eventtype_field_by_name(et
, LTT_FIELD_STATUS
);
2516 status
= ltt_enum_string_get(ltt_field_type(f7
),
2517 ltt_event_get_unsigned(e
, f7
));
2520 f8
= ltt_eventtype_field_by_name(et
, LTT_FIELD_TGID
);
2521 if(f8
) tgid
= ltt_event_get_unsigned(e
, f8
);
2526 nb_cpus
= ltt_trace_get_num_cpu(ts
->parent
.t
);
2527 for(i
=0; i
<nb_cpus
; i
++) {
2528 process
= lttv_state_find_process(ts
, i
, pid
);
2529 g_assert(process
!= NULL
);
2531 process
->ppid
= parent_pid
;
2532 process
->tgid
= tgid
;
2533 process
->name
= g_quark_from_string(command
);
2535 &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
2536 process
->type
= LTTV_STATE_KERNEL_THREAD
;
2540 /* The process might exist if a process was forked while performing the
2542 process
= lttv_state_find_process(ts
, ANY_CPU
, pid
);
2543 if(process
== NULL
) {
2544 parent_process
= lttv_state_find_process(ts
, ANY_CPU
, parent_pid
);
2545 process
= lttv_state_create_process(ts
, parent_process
, cpu
,
2546 pid
, tgid
, g_quark_from_string(command
),
2547 &s
->parent
.timestamp
);
2549 /* Keep the stack bottom : a running user mode */
2550 /* Disabled because of inconsistencies in the current statedump states. */
2551 if(type
== LTTV_STATE_KERNEL_THREAD
) {
2552 /* Only keep the bottom
2553 * FIXME Kernel thread : can be in syscall or interrupt or trap. */
2554 /* Will cause expected trap when in fact being syscall (even after end of
2556 * Will cause expected interrupt when being syscall. (only before end of
2557 * statedump event) */
2558 // This will cause a "popping last state on stack, ignoring it."
2559 process
->execution_stack
= g_array_set_size(process
->execution_stack
, 1);
2560 es
= process
->state
= &g_array_index(process
->execution_stack
,
2561 LttvExecutionState
, 0);
2562 process
->type
= LTTV_STATE_KERNEL_THREAD
;
2563 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
2564 es
->s
= LTTV_STATE_UNNAMED
;
2565 es
->n
= LTTV_STATE_SUBMODE_UNKNOWN
;
2567 es
->t
= LTTV_STATE_SYSCALL
;
2572 /* User space process :
2573 * bottom : user mode
2574 * either currently running or scheduled out.
2575 * can be scheduled out because interrupted in (user mode or in syscall)
2576 * or because of an explicit call to the scheduler in syscall. Note that
2577 * the scheduler call comes after the irq_exit, so never in interrupt
2579 // temp workaround : set size to 1 : only have user mode bottom of stack.
2580 // will cause g_info message of expected syscall mode when in fact being
2581 // in user mode. Can also cause expected trap when in fact being user
2582 // mode in the event of a page fault reenabling interrupts in the handler.
2583 // Expected syscall and trap can also happen after the end of statedump
2584 // This will cause a "popping last state on stack, ignoring it."
2585 process
->execution_stack
= g_array_set_size(process
->execution_stack
, 1);
2586 es
= process
->state
= &g_array_index(process
->execution_stack
,
2587 LttvExecutionState
, 0);
2588 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
2589 es
->s
= LTTV_STATE_UNNAMED
;
2590 es
->n
= LTTV_STATE_SUBMODE_UNKNOWN
;
2592 es
->t
= LTTV_STATE_USER_MODE
;
2600 es
= process
->state
= &g_array_index(process
->execution_stack
,
2601 LttvExecutionState
, 1);
2602 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
2603 es
->s
= LTTV_STATE_UNNAMED
;
2604 es
->n
= LTTV_STATE_SUBMODE_UNKNOWN
;
2608 /* The process has already been created :
2609 * Probably was forked while dumping the process state or
2610 * was simply scheduled in prior to get the state dump event.
2612 process
->ppid
= parent_pid
;
2613 process
->tgid
= tgid
;
2614 process
->name
= g_quark_from_string(command
);
2615 process
->type
= type
;
2617 &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
2619 if(es
->t
== LTTV_STATE_MODE_UNKNOWN
) {
2620 if(type
== LTTV_STATE_KERNEL_THREAD
)
2621 es
->t
= LTTV_STATE_SYSCALL
;
2623 es
->t
= LTTV_STATE_USER_MODE
;
2626 /* Don't mess around with the stack, it will eventually become
2627 * ok after the end of state dump. */
2634 gint
lttv_state_hook_add_event_hooks(void *hook_data
, void *call_data
)
2636 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
2638 lttv_state_add_event_hooks(tss
);
2643 void lttv_state_add_event_hooks(LttvTracesetState
*self
)
2645 LttvTraceset
*traceset
= self
->parent
.ts
;
2647 guint i
, j
, k
, l
, nb_trace
, nb_tracefile
;
2651 LttvTracefileState
*tfs
;
2655 LttvTraceHookByFacility
*thf
;
2657 LttvTraceHook
*hook
;
2659 LttvAttributeValue val
;
2664 nb_trace
= lttv_traceset_number(traceset
);
2665 for(i
= 0 ; i
< nb_trace
; i
++) {
2666 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
2668 /* Find the eventtype id for the following events and register the
2669 associated by id hooks. */
2671 hooks
= g_array_sized_new(FALSE
, FALSE
, sizeof(LttvTraceHook
), 19);
2672 hooks
= g_array_set_size(hooks
, 19); // Max possible number of hooks.
2675 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2676 LTT_FACILITY_KERNEL_ARCH
, LTT_EVENT_SYSCALL_ENTRY
,
2677 LTT_FIELD_SYSCALL_ID
, 0, 0,
2678 syscall_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2681 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2682 LTT_FACILITY_KERNEL_ARCH
, LTT_EVENT_SYSCALL_EXIT
,
2684 syscall_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2687 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2688 LTT_FACILITY_KERNEL_ARCH
, LTT_EVENT_TRAP_ENTRY
,
2689 LTT_FIELD_TRAP_ID
, 0, 0,
2690 trap_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2693 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2694 LTT_FACILITY_KERNEL_ARCH
, LTT_EVENT_TRAP_EXIT
,
2696 trap_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2699 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2700 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_ENTRY
,
2701 LTT_FIELD_IRQ_ID
, 0, 0,
2702 irq_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2705 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2706 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_EXIT
,
2708 irq_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2711 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2712 LTT_FACILITY_KERNEL
, LTT_EVENT_SOFT_IRQ_ENTRY
,
2713 LTT_FIELD_SOFT_IRQ_ID
, 0, 0,
2714 soft_irq_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2717 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2718 LTT_FACILITY_KERNEL
, LTT_EVENT_SOFT_IRQ_EXIT
,
2720 soft_irq_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2723 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2724 LTT_FACILITY_KERNEL
, LTT_EVENT_SCHED_SCHEDULE
,
2725 LTT_FIELD_OUT
, LTT_FIELD_IN
, LTT_FIELD_OUT_STATE
,
2726 schedchange
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2729 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2730 LTT_FACILITY_KERNEL
, LTT_EVENT_PROCESS_FORK
,
2731 LTT_FIELD_PARENT_PID
, LTT_FIELD_CHILD_PID
, LTT_FIELD_TGID
,
2732 process_fork
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2735 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2736 LTT_FACILITY_KERNEL_ARCH
, LTT_EVENT_KTHREAD_CREATE
,
2737 LTT_FIELD_PID
, 0, 0,
2738 process_kernel_thread
, NULL
, &g_array_index(hooks
, LttvTraceHook
,
2742 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2743 LTT_FACILITY_KERNEL
, LTT_EVENT_PROCESS_EXIT
,
2744 LTT_FIELD_PID
, 0, 0,
2745 process_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2748 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2749 LTT_FACILITY_KERNEL
, LTT_EVENT_PROCESS_FREE
,
2750 LTT_FIELD_PID
, 0, 0,
2751 process_free
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2754 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2755 LTT_FACILITY_FS
, LTT_EVENT_EXEC
,
2756 LTT_FIELD_FILENAME
, 0, 0,
2757 process_exec
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2760 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2761 LTT_FACILITY_USER_GENERIC
, LTT_EVENT_THREAD_BRAND
,
2762 LTT_FIELD_NAME
, 0, 0,
2763 thread_brand
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2766 /* statedump-related hooks */
2767 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2768 LTT_FACILITY_LIST
, LTT_EVENT_PROCESS_STATE
,
2769 LTT_FIELD_PID
, LTT_FIELD_PARENT_PID
, LTT_FIELD_NAME
,
2770 enum_process_state
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2773 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2774 LTT_FACILITY_LIST
, LTT_EVENT_STATEDUMP_END
,
2776 statedump_end
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2779 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2780 LTT_FACILITY_USER_GENERIC
, LTT_EVENT_FUNCTION_ENTRY
,
2781 LTT_FIELD_THIS_FN
, LTT_FIELD_CALL_SITE
, 0,
2782 function_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2785 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2786 LTT_FACILITY_USER_GENERIC
, LTT_EVENT_FUNCTION_EXIT
,
2787 LTT_FIELD_THIS_FN
, LTT_FIELD_CALL_SITE
, 0,
2788 function_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2791 hooks
= g_array_set_size(hooks
, hn
);
2793 /* Add these hooks to each event_by_id hooks list */
2795 nb_tracefile
= ts
->parent
.tracefiles
->len
;
2797 for(j
= 0 ; j
< nb_tracefile
; j
++) {
2799 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
2800 LttvTracefileContext
*, j
));
2802 for(k
= 0 ; k
< hooks
->len
; k
++) {
2803 hook
= &g_array_index(hooks
, LttvTraceHook
, k
);
2804 for(l
=0;l
<hook
->fac_list
->len
;l
++) {
2805 thf
= g_array_index(hook
->fac_list
, LttvTraceHookByFacility
*, l
);
2807 lttv_hooks_by_id_find(tfs
->parent
.event_by_id
, thf
->id
),
2814 lttv_attribute_find(ts
->parent
.a
, LTTV_STATE_HOOKS
, LTTV_POINTER
, &val
);
2815 *(val
.v_pointer
) = hooks
;
2819 gint
lttv_state_hook_remove_event_hooks(void *hook_data
, void *call_data
)
2821 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
2823 lttv_state_remove_event_hooks(tss
);
2828 void lttv_state_remove_event_hooks(LttvTracesetState
*self
)
2830 LttvTraceset
*traceset
= self
->parent
.ts
;
2832 guint i
, j
, k
, l
, nb_trace
, nb_tracefile
;
2836 LttvTracefileState
*tfs
;
2840 LttvTraceHook
*hook
;
2842 LttvTraceHookByFacility
*thf
;
2844 LttvAttributeValue val
;
2846 nb_trace
= lttv_traceset_number(traceset
);
2847 for(i
= 0 ; i
< nb_trace
; i
++) {
2848 ts
= LTTV_TRACE_STATE(self
->parent
.traces
[i
]);
2850 lttv_attribute_find(ts
->parent
.a
, LTTV_STATE_HOOKS
, LTTV_POINTER
, &val
);
2851 hooks
= *(val
.v_pointer
);
2853 /* Remove these hooks from each event_by_id hooks list */
2855 nb_tracefile
= ts
->parent
.tracefiles
->len
;
2857 for(j
= 0 ; j
< nb_tracefile
; j
++) {
2859 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
2860 LttvTracefileContext
*, j
));
2862 for(k
= 0 ; k
< hooks
->len
; k
++) {
2863 hook
= &g_array_index(hooks
, LttvTraceHook
, k
);
2864 for(l
=0;l
<hook
->fac_list
->len
;l
++) {
2865 thf
= g_array_index(hook
->fac_list
, LttvTraceHookByFacility
*, l
);
2867 lttv_hooks_remove_data(
2868 lttv_hooks_by_id_find(tfs
->parent
.event_by_id
, thf
->id
),
2874 for(k
= 0 ; k
< hooks
->len
; k
++)
2875 lttv_trace_hook_destroy(&g_array_index(hooks
, LttvTraceHook
, k
));
2876 g_array_free(hooks
, TRUE
);
2880 static gboolean
state_save_event_hook(void *hook_data
, void *call_data
)
2882 guint
*event_count
= (guint
*)hook_data
;
2884 /* Only save at LTTV_STATE_SAVE_INTERVAL */
2885 if(likely((*event_count
)++ < LTTV_STATE_SAVE_INTERVAL
))
2890 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
2892 LttvTracefileState
*tfcs
;
2894 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
2896 LttEventPosition
*ep
;
2902 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
2904 LttvAttributeValue value
;
2906 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
2907 LTTV_STATE_SAVED_STATES
);
2908 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
2909 value
= lttv_attribute_add(saved_states_tree
,
2910 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
2911 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
2912 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
2913 *(value
.v_time
) = self
->parent
.timestamp
;
2914 lttv_state_save(tcs
, saved_state_tree
);
2915 g_debug("Saving state at time %lu.%lu", self
->parent
.timestamp
.tv_sec
,
2916 self
->parent
.timestamp
.tv_nsec
);
2918 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
2923 static gboolean
state_save_after_trace_hook(void *hook_data
, void *call_data
)
2925 LttvTraceState
*tcs
= (LttvTraceState
*)(call_data
);
2927 *(tcs
->max_time_state_recomputed_in_seek
) = tcs
->parent
.time_span
.end_time
;
2932 guint
lttv_state_current_cpu(LttvTracefileState
*tfs
)
2940 static gboolean
block_start(void *hook_data
, void *call_data
)
2942 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
2944 LttvTracefileState
*tfcs
;
2946 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
2948 LttEventPosition
*ep
;
2950 guint i
, nb_block
, nb_event
, nb_tracefile
;
2954 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
2956 LttvAttributeValue value
;
2958 ep
= ltt_event_position_new();
2960 nb_tracefile
= tcs
->parent
.tracefiles
->len
;
2962 /* Count the number of events added since the last block end in any
2965 for(i
= 0 ; i
< nb_tracefile
; i
++) {
2967 LTTV_TRACEFILE_STATE(&g_array_index(tcs
->parent
.tracefiles
,
2968 LttvTracefileContext
, i
));
2969 ltt_event_position(tfcs
->parent
.e
, ep
);
2970 ltt_event_position_get(ep
, &nb_block
, &nb_event
, &tf
);
2971 tcs
->nb_event
+= nb_event
- tfcs
->saved_position
;
2972 tfcs
->saved_position
= nb_event
;
2976 if(tcs
->nb_event
>= tcs
->save_interval
) {
2977 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
2978 LTTV_STATE_SAVED_STATES
);
2979 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
2980 value
= lttv_attribute_add(saved_states_tree
,
2981 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
2982 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
2983 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
2984 *(value
.v_time
) = self
->parent
.timestamp
;
2985 lttv_state_save(tcs
, saved_state_tree
);
2987 g_debug("Saving state at time %lu.%lu", self
->parent
.timestamp
.tv_sec
,
2988 self
->parent
.timestamp
.tv_nsec
);
2990 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
2996 static gboolean
block_end(void *hook_data
, void *call_data
)
2998 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
3000 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
3004 LttEventPosition
*ep
;
3006 guint nb_block
, nb_event
;
3008 ep
= ltt_event_position_new();
3009 ltt_event_position(self
->parent
.e
, ep
);
3010 ltt_event_position_get(ep
, &nb_block
, &nb_event
, &tf
);
3011 tcs
->nb_event
+= nb_event
- self
->saved_position
+ 1;
3012 self
->saved_position
= 0;
3013 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
3020 void lttv_state_save_add_event_hooks(LttvTracesetState
*self
)
3022 LttvTraceset
*traceset
= self
->parent
.ts
;
3024 guint i
, j
, nb_trace
, nb_tracefile
;
3028 LttvTracefileState
*tfs
;
3030 LttvTraceHook hook_start
, hook_end
;
3032 nb_trace
= lttv_traceset_number(traceset
);
3033 for(i
= 0 ; i
< nb_trace
; i
++) {
3034 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
3036 lttv_trace_find_hook(ts
->parent
.t
, "core","block_start",NULL
,
3037 NULL
, NULL
, block_start
, &hook_start
);
3038 lttv_trace_find_hook(ts
->parent
.t
, "core","block_end",NULL
,
3039 NULL
, NULL
, block_end
, &hook_end
);
3041 nb_tracefile
= ts
->parent
.tracefiles
->len
;
3043 for(j
= 0 ; j
< nb_tracefile
; j
++) {
3045 LTTV_TRACEFILE_STATE(&g_array_index(ts
->parent
.tracefiles
,
3046 LttvTracefileContext
, j
));
3047 lttv_hooks_add(lttv_hooks_by_id_find(tfs
->parent
.event_by_id
,
3048 hook_start
.id
), hook_start
.h
, NULL
, LTTV_PRIO_STATE
);
3049 lttv_hooks_add(lttv_hooks_by_id_find(tfs
->parent
.event_by_id
,
3050 hook_end
.id
), hook_end
.h
, NULL
, LTTV_PRIO_STATE
);
3056 void lttv_state_save_add_event_hooks(LttvTracesetState
*self
)
3058 LttvTraceset
*traceset
= self
->parent
.ts
;
3060 guint i
, j
, nb_trace
, nb_tracefile
;
3064 LttvTracefileState
*tfs
;
3067 nb_trace
= lttv_traceset_number(traceset
);
3068 for(i
= 0 ; i
< nb_trace
; i
++) {
3070 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
3071 nb_tracefile
= ts
->parent
.tracefiles
->len
;
3073 if(ts
->has_precomputed_states
) continue;
3075 guint
*event_count
= g_new(guint
, 1);
3078 for(j
= 0 ; j
< nb_tracefile
; j
++) {
3080 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
3081 LttvTracefileContext
*, j
));
3082 lttv_hooks_add(tfs
->parent
.event
,
3083 state_save_event_hook
,
3090 lttv_process_traceset_begin(&self
->parent
,
3091 NULL
, NULL
, NULL
, NULL
, NULL
);
3095 gint
lttv_state_save_hook_add_event_hooks(void *hook_data
, void *call_data
)
3097 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
3099 lttv_state_save_add_event_hooks(tss
);
3106 void lttv_state_save_remove_event_hooks(LttvTracesetState
*self
)
3108 LttvTraceset
*traceset
= self
->parent
.ts
;
3110 guint i
, j
, nb_trace
, nb_tracefile
;
3114 LttvTracefileState
*tfs
;
3116 LttvTraceHook hook_start
, hook_end
;
3118 nb_trace
= lttv_traceset_number(traceset
);
3119 for(i
= 0 ; i
< nb_trace
; i
++) {
3120 ts
= LTTV_TRACE_STATE(self
->parent
.traces
[i
]);
3122 lttv_trace_find_hook(ts
->parent
.t
, "core","block_start",NULL
,
3123 NULL
, NULL
, block_start
, &hook_start
);
3125 lttv_trace_find_hook(ts
->parent
.t
, "core","block_end",NULL
,
3126 NULL
, NULL
, block_end
, &hook_end
);
3128 nb_tracefile
= ts
->parent
.tracefiles
->len
;
3130 for(j
= 0 ; j
< nb_tracefile
; j
++) {
3132 LTTV_TRACEFILE_STATE(&g_array_index(ts
->parent
.tracefiles
,
3133 LttvTracefileContext
, j
));
3134 lttv_hooks_remove_data(lttv_hooks_by_id_find(
3135 tfs
->parent
.event_by_id
, hook_start
.id
), hook_start
.h
, NULL
);
3136 lttv_hooks_remove_data(lttv_hooks_by_id_find(
3137 tfs
->parent
.event_by_id
, hook_end
.id
), hook_end
.h
, NULL
);
3143 void lttv_state_save_remove_event_hooks(LttvTracesetState
*self
)
3145 LttvTraceset
*traceset
= self
->parent
.ts
;
3147 guint i
, j
, nb_trace
, nb_tracefile
;
3151 LttvTracefileState
*tfs
;
3153 LttvHooks
*after_trace
= lttv_hooks_new();
3155 lttv_hooks_add(after_trace
,
3156 state_save_after_trace_hook
,
3161 lttv_process_traceset_end(&self
->parent
,
3162 NULL
, after_trace
, NULL
, NULL
, NULL
);
3164 lttv_hooks_destroy(after_trace
);
3166 nb_trace
= lttv_traceset_number(traceset
);
3167 for(i
= 0 ; i
< nb_trace
; i
++) {
3169 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
3170 nb_tracefile
= ts
->parent
.tracefiles
->len
;
3172 if(ts
->has_precomputed_states
) continue;
3174 guint
*event_count
= NULL
;
3176 for(j
= 0 ; j
< nb_tracefile
; j
++) {
3178 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
3179 LttvTracefileContext
*, j
));
3180 event_count
= lttv_hooks_remove(tfs
->parent
.event
,
3181 state_save_event_hook
);
3183 if(event_count
) g_free(event_count
);
3187 gint
lttv_state_save_hook_remove_event_hooks(void *hook_data
, void *call_data
)
3189 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
3191 lttv_state_save_remove_event_hooks(tss
);
3196 void lttv_state_traceset_seek_time_closest(LttvTracesetState
*self
, LttTime t
)
3198 LttvTraceset
*traceset
= self
->parent
.ts
;
3202 int min_pos
, mid_pos
, max_pos
;
3204 guint call_rest
= 0;
3206 LttvTraceState
*tcs
;
3208 LttvAttributeValue value
;
3210 LttvAttributeType type
;
3212 LttvAttributeName name
;
3216 LttvAttribute
*saved_states_tree
, *saved_state_tree
, *closest_tree
;
3218 //g_tree_destroy(self->parent.pqueue);
3219 //self->parent.pqueue = g_tree_new(compare_tracefile);
3221 g_info("Entering seek_time_closest for time %lu.%lu", t
.tv_sec
, t
.tv_nsec
);
3223 nb_trace
= lttv_traceset_number(traceset
);
3224 for(i
= 0 ; i
< nb_trace
; i
++) {
3225 tcs
= (LttvTraceState
*)self
->parent
.traces
[i
];
3227 if(ltt_time_compare(t
, *(tcs
->max_time_state_recomputed_in_seek
)) < 0) {
3228 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
3229 LTTV_STATE_SAVED_STATES
);
3232 if(saved_states_tree
) {
3233 max_pos
= lttv_attribute_get_number(saved_states_tree
) - 1;
3234 mid_pos
= max_pos
/ 2;
3235 while(min_pos
< max_pos
) {
3236 type
= lttv_attribute_get(saved_states_tree
, mid_pos
, &name
, &value
,
3238 g_assert(type
== LTTV_GOBJECT
);
3239 saved_state_tree
= *((LttvAttribute
**)(value
.v_gobject
));
3240 type
= lttv_attribute_get_by_name(saved_state_tree
, LTTV_STATE_TIME
,
3242 g_assert(type
== LTTV_TIME
);
3243 if(ltt_time_compare(*(value
.v_time
), t
) < 0) {
3245 closest_tree
= saved_state_tree
;
3247 else max_pos
= mid_pos
- 1;
3249 mid_pos
= (min_pos
+ max_pos
+ 1) / 2;
3253 /* restore the closest earlier saved state */
3255 lttv_state_restore(tcs
, closest_tree
);
3259 /* There is no saved state, yet we want to have it. Restart at T0 */
3261 restore_init_state(tcs
);
3262 lttv_process_trace_seek_time(&(tcs
->parent
), ltt_time_zero
);
3265 /* We want to seek quickly without restoring/updating the state */
3267 restore_init_state(tcs
);
3268 lttv_process_trace_seek_time(&(tcs
->parent
), t
);
3271 if(!call_rest
) g_info("NOT Calling restore");
3276 traceset_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
3282 traceset_state_finalize (LttvTracesetState
*self
)
3284 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
3285 finalize(G_OBJECT(self
));
3290 traceset_state_class_init (LttvTracesetContextClass
*klass
)
3292 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
3294 gobject_class
->finalize
= (void (*)(GObject
*self
)) traceset_state_finalize
;
3295 klass
->init
= (void (*)(LttvTracesetContext
*self
, LttvTraceset
*ts
))init
;
3296 klass
->fini
= (void (*)(LttvTracesetContext
*self
))fini
;
3297 klass
->new_traceset_context
= new_traceset_context
;
3298 klass
->new_trace_context
= new_trace_context
;
3299 klass
->new_tracefile_context
= new_tracefile_context
;
3304 lttv_traceset_state_get_type(void)
3306 static GType type
= 0;
3308 static const GTypeInfo info
= {
3309 sizeof (LttvTracesetStateClass
),
3310 NULL
, /* base_init */
3311 NULL
, /* base_finalize */
3312 (GClassInitFunc
) traceset_state_class_init
, /* class_init */
3313 NULL
, /* class_finalize */
3314 NULL
, /* class_data */
3315 sizeof (LttvTracesetState
),
3316 0, /* n_preallocs */
3317 (GInstanceInitFunc
) traceset_state_instance_init
, /* instance_init */
3318 NULL
/* value handling */
3321 type
= g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE
, "LttvTracesetStateType",
3329 trace_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
3335 trace_state_finalize (LttvTraceState
*self
)
3337 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_CONTEXT_TYPE
))->
3338 finalize(G_OBJECT(self
));
3343 trace_state_class_init (LttvTraceStateClass
*klass
)
3345 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
3347 gobject_class
->finalize
= (void (*)(GObject
*self
)) trace_state_finalize
;
3348 klass
->state_save
= state_save
;
3349 klass
->state_restore
= state_restore
;
3350 klass
->state_saved_free
= state_saved_free
;
3355 lttv_trace_state_get_type(void)
3357 static GType type
= 0;
3359 static const GTypeInfo info
= {
3360 sizeof (LttvTraceStateClass
),
3361 NULL
, /* base_init */
3362 NULL
, /* base_finalize */
3363 (GClassInitFunc
) trace_state_class_init
, /* class_init */
3364 NULL
, /* class_finalize */
3365 NULL
, /* class_data */
3366 sizeof (LttvTraceState
),
3367 0, /* n_preallocs */
3368 (GInstanceInitFunc
) trace_state_instance_init
, /* instance_init */
3369 NULL
/* value handling */
3372 type
= g_type_register_static (LTTV_TRACE_CONTEXT_TYPE
,
3373 "LttvTraceStateType", &info
, 0);
3380 tracefile_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
3386 tracefile_state_finalize (LttvTracefileState
*self
)
3388 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_CONTEXT_TYPE
))->
3389 finalize(G_OBJECT(self
));
3394 tracefile_state_class_init (LttvTracefileStateClass
*klass
)
3396 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
3398 gobject_class
->finalize
= (void (*)(GObject
*self
)) tracefile_state_finalize
;
3403 lttv_tracefile_state_get_type(void)
3405 static GType type
= 0;
3407 static const GTypeInfo info
= {
3408 sizeof (LttvTracefileStateClass
),
3409 NULL
, /* base_init */
3410 NULL
, /* base_finalize */
3411 (GClassInitFunc
) tracefile_state_class_init
, /* class_init */
3412 NULL
, /* class_finalize */
3413 NULL
, /* class_data */
3414 sizeof (LttvTracefileState
),
3415 0, /* n_preallocs */
3416 (GInstanceInitFunc
) tracefile_state_instance_init
, /* instance_init */
3417 NULL
/* value handling */
3420 type
= g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE
,
3421 "LttvTracefileStateType", &info
, 0);
3427 static void module_init()
3429 LTTV_STATE_UNNAMED
= g_quark_from_string("UNNAMED");
3430 LTTV_STATE_UNBRANDED
= g_quark_from_string("UNBRANDED");
3431 LTTV_STATE_MODE_UNKNOWN
= g_quark_from_string("MODE_UNKNOWN");
3432 LTTV_STATE_USER_MODE
= g_quark_from_string("USER_MODE");
3433 LTTV_STATE_SYSCALL
= g_quark_from_string("SYSCALL");
3434 LTTV_STATE_TRAP
= g_quark_from_string("TRAP");
3435 LTTV_STATE_IRQ
= g_quark_from_string("IRQ");
3436 LTTV_STATE_SOFT_IRQ
= g_quark_from_string("SOFTIRQ");
3437 LTTV_STATE_SUBMODE_UNKNOWN
= g_quark_from_string("UNKNOWN");
3438 LTTV_STATE_SUBMODE_NONE
= g_quark_from_string("NONE");
3439 LTTV_STATE_WAIT_FORK
= g_quark_from_string("WAIT_FORK");
3440 LTTV_STATE_WAIT_CPU
= g_quark_from_string("WAIT_CPU");
3441 LTTV_STATE_EXIT
= g_quark_from_string("EXIT");
3442 LTTV_STATE_ZOMBIE
= g_quark_from_string("ZOMBIE");
3443 LTTV_STATE_WAIT
= g_quark_from_string("WAIT");
3444 LTTV_STATE_RUN
= g_quark_from_string("RUN");
3445 LTTV_STATE_DEAD
= g_quark_from_string("DEAD");
3446 LTTV_STATE_USER_THREAD
= g_quark_from_string("USER_THREAD");
3447 LTTV_STATE_KERNEL_THREAD
= g_quark_from_string("KERNEL_THREAD");
3448 LTTV_STATE_TRACEFILES
= g_quark_from_string("tracefiles");
3449 LTTV_STATE_PROCESSES
= g_quark_from_string("processes");
3450 LTTV_STATE_PROCESS
= g_quark_from_string("process");
3451 LTTV_STATE_RUNNING_PROCESS
= g_quark_from_string("running_process");
3452 LTTV_STATE_EVENT
= g_quark_from_string("event");
3453 LTTV_STATE_SAVED_STATES
= g_quark_from_string("saved states");
3454 LTTV_STATE_SAVED_STATES_TIME
= g_quark_from_string("saved states time");
3455 LTTV_STATE_TIME
= g_quark_from_string("time");
3456 LTTV_STATE_HOOKS
= g_quark_from_string("saved state hooks");
3457 LTTV_STATE_NAME_TABLES
= g_quark_from_string("name tables");
3458 LTTV_STATE_TRACE_STATE_USE_COUNT
=
3459 g_quark_from_string("trace_state_use_count");
3462 LTT_FACILITY_KERNEL
= g_quark_from_string("kernel");
3463 LTT_FACILITY_KERNEL_ARCH
= g_quark_from_string("kernel_arch");
3464 LTT_FACILITY_FS
= g_quark_from_string("fs");
3465 LTT_FACILITY_LIST
= g_quark_from_string("list");
3466 LTT_FACILITY_USER_GENERIC
= g_quark_from_string("user_generic");
3469 LTT_EVENT_SYSCALL_ENTRY
= g_quark_from_string("syscall_entry");
3470 LTT_EVENT_SYSCALL_EXIT
= g_quark_from_string("syscall_exit");
3471 LTT_EVENT_TRAP_ENTRY
= g_quark_from_string("trap_entry");
3472 LTT_EVENT_TRAP_EXIT
= g_quark_from_string("trap_exit");
3473 LTT_EVENT_IRQ_ENTRY
= g_quark_from_string("irq_entry");
3474 LTT_EVENT_IRQ_EXIT
= g_quark_from_string("irq_exit");
3475 LTT_EVENT_SOFT_IRQ_ENTRY
= g_quark_from_string("soft_irq_entry");
3476 LTT_EVENT_SOFT_IRQ_EXIT
= g_quark_from_string("soft_irq_exit");
3477 LTT_EVENT_SCHED_SCHEDULE
= g_quark_from_string("sched_schedule");
3478 LTT_EVENT_PROCESS_FORK
= g_quark_from_string("process_fork");
3479 LTT_EVENT_KTHREAD_CREATE
= g_quark_from_string("kthread_create");
3480 LTT_EVENT_PROCESS_EXIT
= g_quark_from_string("process_exit");
3481 LTT_EVENT_PROCESS_FREE
= g_quark_from_string("procesS_free");
3482 LTT_EVENT_EXEC
= g_quark_from_string("exec");
3483 LTT_EVENT_PROCESS_STATE
= g_quark_from_string("process_state");
3484 LTT_EVENT_STATEDUMP_END
= g_quark_from_string("statedump_end");
3485 LTT_EVENT_FUNCTION_ENTRY
= g_quark_from_string("function_entry");
3486 LTT_EVENT_FUNCTION_EXIT
= g_quark_from_string("function_exit");
3487 LTT_EVENT_THREAD_BRAND
= g_quark_from_string("thread_brand");
3490 LTT_FIELD_SYSCALL_ID
= g_quark_from_string("syscall_id");
3491 LTT_FIELD_TRAP_ID
= g_quark_from_string("trap_id");
3492 LTT_FIELD_IRQ_ID
= g_quark_from_string("irq_id");
3493 LTT_FIELD_SOFT_IRQ_ID
= g_quark_from_string("softirq_id");
3494 LTT_FIELD_OUT
= g_quark_from_string("out");
3495 LTT_FIELD_IN
= g_quark_from_string("in");
3496 LTT_FIELD_OUT_STATE
= g_quark_from_string("out_state");
3497 LTT_FIELD_PARENT_PID
= g_quark_from_string("parent_pid");
3498 LTT_FIELD_CHILD_PID
= g_quark_from_string("child_pid");
3499 LTT_FIELD_PID
= g_quark_from_string("pid");
3500 LTT_FIELD_TGID
= g_quark_from_string("tgid");
3501 LTT_FIELD_FILENAME
= g_quark_from_string("filename");
3502 LTT_FIELD_NAME
= g_quark_from_string("name");
3503 LTT_FIELD_TYPE
= g_quark_from_string("type");
3504 LTT_FIELD_MODE
= g_quark_from_string("mode");
3505 LTT_FIELD_SUBMODE
= g_quark_from_string("submode");
3506 LTT_FIELD_STATUS
= g_quark_from_string("status");
3507 LTT_FIELD_THIS_FN
= g_quark_from_string("this_fn");
3508 LTT_FIELD_CALL_SITE
= g_quark_from_string("call_site");
3512 static void module_destroy()
3517 LTTV_MODULE("state", "State computation", \
3518 "Update the system state, possibly saving it at intervals", \
3519 module_init
, module_destroy
)