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_STATEDUMP
,
53 LTT_FACILITY_USER_GENERIC
;
58 LTT_EVENT_SYSCALL_ENTRY
,
59 LTT_EVENT_SYSCALL_EXIT
,
64 LTT_EVENT_SOFT_IRQ_ENTRY
,
65 LTT_EVENT_SOFT_IRQ_EXIT
,
66 LTT_EVENT_SCHEDCHANGE
,
68 LTT_EVENT_KERNEL_THREAD
,
72 LTT_EVENT_ENUM_PROCESS_STATE
,
73 LTT_EVENT_STATEDUMP_END
,
74 LTT_EVENT_FUNCTION_ENTRY
,
75 LTT_EVENT_FUNCTION_EXIT
,
76 LTT_EVENT_THREAD_BRAND
;
84 LTT_FIELD_SOFT_IRQ_ID
,
102 LTTV_STATE_MODE_UNKNOWN
,
103 LTTV_STATE_USER_MODE
,
110 LTTV_STATE_SUBMODE_UNKNOWN
,
111 LTTV_STATE_SUBMODE_NONE
;
115 LTTV_STATE_UNBRANDED
,
116 LTTV_STATE_WAIT_FORK
,
125 LTTV_STATE_USER_THREAD
,
126 LTTV_STATE_KERNEL_THREAD
;
129 LTTV_STATE_TRACEFILES
,
130 LTTV_STATE_PROCESSES
,
132 LTTV_STATE_RUNNING_PROCESS
,
134 LTTV_STATE_SAVED_STATES
,
135 LTTV_STATE_SAVED_STATES_TIME
,
138 LTTV_STATE_NAME_TABLES
,
139 LTTV_STATE_TRACE_STATE_USE_COUNT
;
141 static void create_max_time(LttvTraceState
*tcs
);
143 static void get_max_time(LttvTraceState
*tcs
);
145 static void free_max_time(LttvTraceState
*tcs
);
147 static void create_name_tables(LttvTraceState
*tcs
);
149 static void get_name_tables(LttvTraceState
*tcs
);
151 static void free_name_tables(LttvTraceState
*tcs
);
153 static void free_saved_state(LttvTraceState
*tcs
);
155 static void lttv_state_free_process_table(GHashTable
*processes
);
157 static void lttv_trace_states_read_raw(LttvTraceState
*tcs
, FILE *fp
,
158 GPtrArray
*quarktable
);
160 void lttv_state_save(LttvTraceState
*self
, LttvAttribute
*container
)
162 LTTV_TRACE_STATE_GET_CLASS(self
)->state_save(self
, container
);
166 void lttv_state_restore(LttvTraceState
*self
, LttvAttribute
*container
)
168 LTTV_TRACE_STATE_GET_CLASS(self
)->state_restore(self
, container
);
172 void lttv_state_state_saved_free(LttvTraceState
*self
,
173 LttvAttribute
*container
)
175 LTTV_TRACE_STATE_GET_CLASS(self
)->state_saved_free(self
, container
);
179 guint
process_hash(gconstpointer key
)
181 guint pid
= ((const LttvProcessState
*)key
)->pid
;
182 return (pid
>>8 ^ pid
>>4 ^ pid
>>2 ^ pid
) ;
186 /* If the hash table hash function is well distributed,
187 * the process_equal should compare different pid */
188 gboolean
process_equal(gconstpointer a
, gconstpointer b
)
190 const LttvProcessState
*process_a
, *process_b
;
193 process_a
= (const LttvProcessState
*)a
;
194 process_b
= (const LttvProcessState
*)b
;
196 if(likely(process_a
->pid
!= process_b
->pid
)) ret
= FALSE
;
197 else if(likely(process_a
->pid
== 0 &&
198 process_a
->cpu
!= process_b
->cpu
)) ret
= FALSE
;
203 static void delete_usertrace(gpointer key
, gpointer value
, gpointer user_data
)
205 g_tree_destroy((GTree
*)value
);
208 static void lttv_state_free_usertraces(GHashTable
*usertraces
)
210 g_hash_table_foreach(usertraces
, delete_usertrace
, NULL
);
211 g_hash_table_destroy(usertraces
);
217 restore_init_state(LttvTraceState
*self
)
221 LttvTracefileState
*tfcs
;
223 LttTime start_time
, end_time
;
225 /* Free the process tables */
226 if(self
->processes
!= NULL
) lttv_state_free_process_table(self
->processes
);
227 if(self
->usertraces
!= NULL
) lttv_state_free_usertraces(self
->usertraces
);
228 self
->processes
= g_hash_table_new(process_hash
, process_equal
);
229 self
->usertraces
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
232 /* Seek time to beginning */
233 // Mathieu : fix : don't seek traceset here : causes inconsistency in seek
234 // closest. It's the tracecontext job to seek the trace to the beginning
235 // anyway : the init state might be used at the middle of the trace as well...
236 //g_tree_destroy(self->parent.ts_context->pqueue);
237 //self->parent.ts_context->pqueue = g_tree_new(compare_tracefile);
239 ltt_trace_time_span_get(self
->parent
.t
, &start_time
, &end_time
);
241 //lttv_process_trace_seek_time(&self->parent, ltt_time_zero);
243 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
245 /* Put the per cpu running_process to beginning state : process 0. */
246 for(i
=0; i
< nb_cpus
; i
++) {
247 LttvExecutionState
*es
;
248 self
->running_process
[i
] = lttv_state_create_process(self
, NULL
, i
, 0, 0,
249 LTTV_STATE_UNNAMED
, &start_time
);
250 /* We are not sure is it's a kernel thread or normal thread, put the
251 * bottom stack state to unknown */
252 self
->running_process
[i
]->execution_stack
=
253 g_array_set_size(self
->running_process
[i
]->execution_stack
, 1);
254 es
= self
->running_process
[i
]->state
=
255 &g_array_index(self
->running_process
[i
]->execution_stack
,
256 LttvExecutionState
, 0);
257 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
259 self
->running_process
[i
]->state
->s
= LTTV_STATE_RUN
;
260 self
->running_process
[i
]->cpu
= i
;
264 nb_tracefile
= self
->parent
.tracefiles
->len
;
266 for(i
= 0 ; i
< nb_tracefile
; i
++) {
268 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
269 LttvTracefileContext
*, i
));
270 ltt_trace_time_span_get(self
->parent
.t
, &tfcs
->parent
.timestamp
, NULL
);
271 // tfcs->saved_position = 0;
272 tfcs
->process
= lttv_state_create_process(tfcs
, NULL
,0);
273 tfcs
->process
->state
->s
= LTTV_STATE_RUN
;
274 tfcs
->process
->last_cpu
= tfcs
->cpu_name
;
275 tfcs
->process
->last_cpu_index
= ltt_tracefile_num(((LttvTracefileContext
*)tfcs
)->tf
);
280 //static LttTime time_zero = {0,0};
282 static gint
compare_usertraces(gconstpointer a
, gconstpointer b
,
285 const LttTime
*t1
= (const LttTime
*)a
;
286 const LttTime
*t2
= (const LttTime
*)b
;
288 return ltt_time_compare(*t1
, *t2
);
291 static void free_usertrace_key(gpointer data
)
296 #define MAX_STRING_LEN 4096
299 state_load_saved_states(LttvTraceState
*tcs
)
302 GPtrArray
*quarktable
;
307 tcs
->has_precomputed_states
= FALSE
;
311 gchar buf
[MAX_STRING_LEN
];
314 trace_path
= g_quark_to_string(ltt_trace_name(tcs
->parent
.t
));
315 strncpy(path
, trace_path
, PATH_MAX
-1);
316 count
= strnlen(trace_path
, PATH_MAX
-1);
317 // quarktable : open, test
318 strncat(path
, "/precomputed/quarktable", PATH_MAX
-count
-1);
319 fp
= fopen(path
, "r");
321 quarktable
= g_ptr_array_sized_new(4096);
323 /* Index 0 is null */
325 if(hdr
== EOF
) return;
326 g_assert(hdr
== HDR_QUARKS
);
330 if(hdr
== EOF
) break;
331 g_assert(hdr
== HDR_QUARK
);
332 g_ptr_array_set_size(quarktable
, q
+1);
335 fread(&buf
[i
], sizeof(gchar
), 1, fp
);
336 if(buf
[i
] == '\0' || feof(fp
)) break;
339 len
= strnlen(buf
, MAX_STRING_LEN
-1);
340 g_ptr_array_index (quarktable
, q
) = g_new(gchar
, len
+1);
341 strncpy(g_ptr_array_index (quarktable
, q
), buf
, len
+1);
347 // saved_states : open, test
348 strncpy(path
, trace_path
, PATH_MAX
-1);
349 count
= strnlen(trace_path
, PATH_MAX
-1);
350 strncat(path
, "/precomputed/states", PATH_MAX
-count
-1);
351 fp
= fopen(path
, "r");
355 if(hdr
!= HDR_TRACE
) goto end
;
357 lttv_trace_states_read_raw(tcs
, fp
, quarktable
);
359 tcs
->has_precomputed_states
= TRUE
;
364 /* Free the quarktable */
365 for(i
=0; i
<quarktable
->len
; i
++) {
366 string
= g_ptr_array_index (quarktable
, i
);
369 g_ptr_array_free(quarktable
, TRUE
);
374 init(LttvTracesetState
*self
, LttvTraceset
*ts
)
376 guint i
, j
, nb_trace
, nb_tracefile
;
378 LttvTraceContext
*tc
;
382 LttvTracefileState
*tfcs
;
384 LttvAttributeValue v
;
386 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
387 init((LttvTracesetContext
*)self
, ts
);
389 nb_trace
= lttv_traceset_number(ts
);
390 for(i
= 0 ; i
< nb_trace
; i
++) {
391 tc
= self
->parent
.traces
[i
];
392 tcs
= LTTV_TRACE_STATE(tc
);
393 tcs
->save_interval
= LTTV_STATE_SAVE_INTERVAL
;
394 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_TRACE_STATE_USE_COUNT
,
398 if(*(v
.v_uint
) == 1) {
399 create_name_tables(tcs
);
400 create_max_time(tcs
);
402 get_name_tables(tcs
);
405 nb_tracefile
= tc
->tracefiles
->len
;
406 tcs
->processes
= NULL
;
407 tcs
->usertraces
= NULL
;
408 tcs
->running_process
= g_new(LttvProcessState
*,
409 ltt_trace_get_num_cpu(tc
->t
));
410 restore_init_state(tcs
);
411 for(j
= 0 ; j
< nb_tracefile
; j
++) {
413 LTTV_TRACEFILE_STATE(g_array_index(tc
->tracefiles
,
414 LttvTracefileContext
*, j
));
415 tfcs
->tracefile_name
= ltt_tracefile_name(tfcs
->parent
.tf
);
416 tfcs
->cpu
= ltt_tracefile_cpu(tfcs
->parent
.tf
);
417 if(ltt_tracefile_tid(tfcs
->parent
.tf
) != 0) {
418 /* It's a Usertrace */
419 guint tid
= ltt_tracefile_tid(tfcs
->parent
.tf
);
420 GTree
*usertrace_tree
= (GTree
*)g_hash_table_lookup(tcs
->usertraces
,
422 if(!usertrace_tree
) {
423 usertrace_tree
= g_tree_new_full(compare_usertraces
,
424 NULL
, free_usertrace_key
, NULL
);
425 g_hash_table_insert(tcs
->usertraces
,
426 (gpointer
)tid
, usertrace_tree
);
428 LttTime
*timestamp
= g_new(LttTime
, 1);
429 *timestamp
= ltt_interpolate_time_from_tsc(tfcs
->parent
.tf
,
430 ltt_tracefile_creation(tfcs
->parent
.tf
));
431 g_tree_insert(usertrace_tree
, timestamp
, tfcs
);
435 /* See if the trace has saved states */
436 state_load_saved_states(tcs
);
441 fini(LttvTracesetState
*self
)
447 LttvTracefileState
*tfcs
;
449 LttvAttributeValue v
;
451 nb_trace
= lttv_traceset_number(LTTV_TRACESET_CONTEXT(self
)->ts
);
452 for(i
= 0 ; i
< nb_trace
; i
++) {
453 tcs
= (LttvTraceState
*)(LTTV_TRACESET_CONTEXT(self
)->traces
[i
]);
454 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_TRACE_STATE_USE_COUNT
,
457 g_assert(*(v
.v_uint
) != 0);
460 if(*(v
.v_uint
) == 0) {
461 free_name_tables(tcs
);
463 free_saved_state(tcs
);
465 g_free(tcs
->running_process
);
466 tcs
->running_process
= NULL
;
467 lttv_state_free_process_table(tcs
->processes
);
468 lttv_state_free_usertraces(tcs
->usertraces
);
469 tcs
->processes
= NULL
;
470 tcs
->usertraces
= NULL
;
472 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
473 fini((LttvTracesetContext
*)self
);
477 static LttvTracesetContext
*
478 new_traceset_context(LttvTracesetContext
*self
)
480 return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE
, NULL
));
484 static LttvTraceContext
*
485 new_trace_context(LttvTracesetContext
*self
)
487 return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE
, NULL
));
491 static LttvTracefileContext
*
492 new_tracefile_context(LttvTracesetContext
*self
)
494 return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE
, NULL
));
498 /* Write the process state of the trace */
500 static void write_process_state(gpointer key
, gpointer value
,
503 LttvProcessState
*process
;
505 LttvExecutionState
*es
;
507 FILE *fp
= (FILE *)user_data
;
512 process
= (LttvProcessState
*)value
;
514 " <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",
515 process
, process
->pid
, process
->tgid
, process
->ppid
,
516 g_quark_to_string(process
->type
),
517 process
->creation_time
.tv_sec
,
518 process
->creation_time
.tv_nsec
,
519 process
->insertion_time
.tv_sec
,
520 process
->insertion_time
.tv_nsec
,
521 g_quark_to_string(process
->name
),
522 g_quark_to_string(process
->brand
),
525 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
526 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
527 fprintf(fp
, " <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
528 g_quark_to_string(es
->t
), g_quark_to_string(es
->n
),
529 es
->entry
.tv_sec
, es
->entry
.tv_nsec
);
530 fprintf(fp
, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
531 es
->change
.tv_sec
, es
->change
.tv_nsec
, g_quark_to_string(es
->s
));
534 for(i
= 0 ; i
< process
->user_stack
->len
; i
++) {
535 address
= &g_array_index(process
->user_stack
, guint64
, i
);
536 fprintf(fp
, " <USER_STACK ADDRESS=\"%llu\"/>\n",
540 if(process
->usertrace
) {
541 fprintf(fp
, " <USERTRACE NAME=\"%s\" CPU=%u\n/>",
542 g_quark_to_string(process
->usertrace
->tracefile_name
),
543 process
->usertrace
->cpu
);
547 fprintf(fp
, " </PROCESS>\n");
551 void lttv_state_write(LttvTraceState
*self
, LttTime t
, FILE *fp
)
553 guint i
, nb_tracefile
, nb_block
, offset
;
556 LttvTracefileState
*tfcs
;
560 LttEventPosition
*ep
;
564 ep
= ltt_event_position_new();
566 fprintf(fp
,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t
.tv_sec
, t
.tv_nsec
);
568 g_hash_table_foreach(self
->processes
, write_process_state
, fp
);
570 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
571 for(i
=0;i
<nb_cpus
;i
++) {
572 fprintf(fp
," <CPU NUM=%u RUNNING_PROCESS=%u>\n",
573 i
, self
->running_process
[i
]->pid
);
576 nb_tracefile
= self
->parent
.tracefiles
->len
;
578 for(i
= 0 ; i
< nb_tracefile
; i
++) {
580 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
581 LttvTracefileContext
*, i
));
582 fprintf(fp
, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
583 tfcs
->parent
.timestamp
.tv_sec
,
584 tfcs
->parent
.timestamp
.tv_nsec
);
585 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
586 if(e
== NULL
) fprintf(fp
,"/>\n");
588 ltt_event_position(e
, ep
);
589 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
590 fprintf(fp
, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block
, offset
,
595 fprintf(fp
,"</PROCESS_STATE>\n");
599 static void write_process_state_raw(gpointer key
, gpointer value
,
602 LttvProcessState
*process
;
604 LttvExecutionState
*es
;
606 FILE *fp
= (FILE *)user_data
;
611 process
= (LttvProcessState
*)value
;
612 fputc(HDR_PROCESS
, fp
);
613 //fwrite(&header, sizeof(header), 1, fp);
614 //fprintf(fp, "%s", g_quark_to_string(process->type));
616 fwrite(&process
->type
, sizeof(process
->type
), 1, fp
);
617 //fprintf(fp, "%s", g_quark_to_string(process->name));
619 fwrite(&process
->name
, sizeof(process
->name
), 1, fp
);
620 //fprintf(fp, "%s", g_quark_to_string(process->brand));
622 fwrite(&process
->brand
, sizeof(process
->brand
), 1, fp
);
623 fwrite(&process
->pid
, sizeof(process
->pid
), 1, fp
);
624 fwrite(&process
->tgid
, sizeof(process
->tgid
), 1, fp
);
625 fwrite(&process
->ppid
, sizeof(process
->ppid
), 1, fp
);
626 fwrite(&process
->cpu
, sizeof(process
->cpu
), 1, fp
);
627 fwrite(&process
->creation_time
, sizeof(process
->creation_time
), 1, fp
);
628 fwrite(&process
->insertion_time
, sizeof(process
->insertion_time
), 1, fp
);
632 " <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",
633 process
, process
->pid
, process
->tgid
, process
->ppid
,
634 g_quark_to_string(process
->type
),
635 process
->creation_time
.tv_sec
,
636 process
->creation_time
.tv_nsec
,
637 process
->insertion_time
.tv_sec
,
638 process
->insertion_time
.tv_nsec
,
639 g_quark_to_string(process
->name
),
640 g_quark_to_string(process
->brand
),
644 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
645 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
648 //fprintf(fp, "%s", g_quark_to_string(es->t));
650 fwrite(&es
->t
, sizeof(es
->t
), 1, fp
);
651 //fprintf(fp, "%s", g_quark_to_string(es->n));
653 fwrite(&es
->n
, sizeof(es
->n
), 1, fp
);
654 //fprintf(fp, "%s", g_quark_to_string(es->s));
656 fwrite(&es
->s
, sizeof(es
->s
), 1, fp
);
657 fwrite(&es
->entry
, sizeof(es
->entry
), 1, fp
);
658 fwrite(&es
->change
, sizeof(es
->change
), 1, fp
);
659 fwrite(&es
->cum_cpu_time
, sizeof(es
->cum_cpu_time
), 1, fp
);
661 fprintf(fp
, " <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
662 g_quark_to_string(es
->t
), g_quark_to_string(es
->n
),
663 es
->entry
.tv_sec
, es
->entry
.tv_nsec
);
664 fprintf(fp
, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
665 es
->change
.tv_sec
, es
->change
.tv_nsec
, g_quark_to_string(es
->s
));
669 for(i
= 0 ; i
< process
->user_stack
->len
; i
++) {
670 address
= &g_array_index(process
->user_stack
, guint64
, i
);
671 fputc(HDR_USER_STACK
, fp
);
672 fwrite(&address
, sizeof(address
), 1, fp
);
674 fprintf(fp
, " <USER_STACK ADDRESS=\"%llu\"/>\n",
679 if(process
->usertrace
) {
680 fputc(HDR_USERTRACE
, fp
);
681 //fprintf(fp, "%s", g_quark_to_string(process->usertrace->tracefile_name));
683 fwrite(&process
->usertrace
->tracefile_name
,
684 sizeof(process
->usertrace
->tracefile_name
), 1, fp
);
685 fwrite(&process
->usertrace
->cpu
, sizeof(process
->usertrace
->cpu
), 1, fp
);
687 fprintf(fp
, " <USERTRACE NAME=\"%s\" CPU=%u\n/>",
688 g_quark_to_string(process
->usertrace
->tracefile_name
),
689 process
->usertrace
->cpu
);
696 void lttv_state_write_raw(LttvTraceState
*self
, LttTime t
, FILE *fp
)
698 guint i
, nb_tracefile
, nb_block
, offset
;
701 LttvTracefileState
*tfcs
;
705 LttEventPosition
*ep
;
709 ep
= ltt_event_position_new();
711 //fprintf(fp,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t.tv_sec, t.tv_nsec);
712 fputc(HDR_PROCESS_STATE
, fp
);
713 fwrite(&t
, sizeof(t
), 1, fp
);
715 g_hash_table_foreach(self
->processes
, write_process_state_raw
, fp
);
717 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
718 for(i
=0;i
<nb_cpus
;i
++) {
720 fwrite(&i
, sizeof(i
), 1, fp
); /* cpu number */
721 fwrite(&self
->running_process
[i
]->pid
,
722 sizeof(self
->running_process
[i
]->pid
), 1, fp
);
723 //fprintf(fp," <CPU NUM=%u RUNNING_PROCESS=%u>\n",
724 // i, self->running_process[i]->pid);
727 nb_tracefile
= self
->parent
.tracefiles
->len
;
729 for(i
= 0 ; i
< nb_tracefile
; i
++) {
731 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
732 LttvTracefileContext
*, i
));
733 // fprintf(fp, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
734 // tfcs->parent.timestamp.tv_sec,
735 // tfcs->parent.timestamp.tv_nsec);
736 fputc(HDR_TRACEFILE
, fp
);
737 fwrite(&tfcs
->parent
.timestamp
, sizeof(tfcs
->parent
.timestamp
), 1, fp
);
738 /* Note : if timestamp if LTT_TIME_INFINITE, there will be no
739 * position following : end of trace */
740 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
742 ltt_event_position(e
, ep
);
743 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
744 //fprintf(fp, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block, offset,
746 fwrite(&nb_block
, sizeof(nb_block
), 1, fp
);
747 fwrite(&offset
, sizeof(offset
), 1, fp
);
748 fwrite(&tsc
, sizeof(tsc
), 1, fp
);
755 /* Read process state from a file */
757 /* Called because a HDR_PROCESS was found */
758 static void read_process_state_raw(LttvTraceState
*self
, FILE *fp
,
759 GPtrArray
*quarktable
)
761 LttvExecutionState
*es
;
762 LttvProcessState
*process
, *parent_process
;
763 LttvProcessState tmp
;
770 /* TODO : check return value */
771 fread(&tmp
.type
, sizeof(tmp
.type
), 1, fp
);
772 fread(&tmp
.name
, sizeof(tmp
.name
), 1, fp
);
773 fread(&tmp
.brand
, sizeof(tmp
.brand
), 1, fp
);
774 fread(&tmp
.pid
, sizeof(tmp
.pid
), 1, fp
);
775 fread(&tmp
.tgid
, sizeof(tmp
.tgid
), 1, fp
);
776 fread(&tmp
.ppid
, sizeof(tmp
.ppid
), 1, fp
);
777 fread(&tmp
.cpu
, sizeof(tmp
.cpu
), 1, fp
);
778 fread(&tmp
.creation_time
, sizeof(tmp
.creation_time
), 1, fp
);
779 fread(&tmp
.insertion_time
, sizeof(tmp
.insertion_time
), 1, fp
);
782 process
= lttv_state_find_process(self
, tmp
.cpu
, tmp
.pid
);
784 /* We must link to the parent */
785 parent_process
= lttv_state_find_process_or_create(self
, ANY_CPU
, tmp
.ppid
,
787 process
= lttv_state_find_process(self
, ANY_CPU
, tmp
.pid
);
788 if(process
== NULL
) {
789 process
= lttv_state_create_process(self
, parent_process
, tmp
.cpu
,
791 g_quark_from_string((gchar
*)g_ptr_array_index(quarktable
, tmp
.name
)),
795 process
->insertion_time
= tmp
.insertion_time
;
796 process
->creation_time
= tmp
.creation_time
;
797 process
->type
= g_quark_from_string(
798 (gchar
*)g_ptr_array_index(quarktable
, tmp
.type
));
799 process
->tgid
= tmp
.tgid
;
800 process
->ppid
= tmp
.ppid
;
801 process
->brand
= g_quark_from_string(
802 (gchar
*)g_ptr_array_index(quarktable
, tmp
.brand
));
804 g_quark_from_string((gchar
*)g_ptr_array_index(quarktable
, tmp
.name
));
808 if(feof(fp
) || ferror(fp
)) goto end_loop
;
810 gint hdr
= fgetc(fp
);
811 if(hdr
== EOF
) goto end_loop
;
815 process
->execution_stack
=
816 g_array_set_size(process
->execution_stack
,
817 process
->execution_stack
->len
+ 1);
818 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
,
819 process
->execution_stack
->len
-1);
822 fread(&es
->t
, sizeof(es
->t
), 1, fp
);
823 es
->t
= g_quark_from_string(
824 (gchar
*)g_ptr_array_index(quarktable
, es
->t
));
825 fread(&es
->n
, sizeof(es
->n
), 1, fp
);
826 es
->n
= g_quark_from_string(
827 (gchar
*)g_ptr_array_index(quarktable
, es
->n
));
828 fread(&es
->s
, sizeof(es
->s
), 1, fp
);
829 es
->s
= g_quark_from_string(
830 (gchar
*)g_ptr_array_index(quarktable
, es
->s
));
831 fread(&es
->entry
, sizeof(es
->entry
), 1, fp
);
832 fread(&es
->change
, sizeof(es
->change
), 1, fp
);
833 fread(&es
->cum_cpu_time
, sizeof(es
->cum_cpu_time
), 1, fp
);
836 process
->user_stack
= g_array_set_size(process
->user_stack
,
837 process
->user_stack
->len
+ 1);
838 address
= &g_array_index(process
->user_stack
, guint64
,
839 process
->user_stack
->len
-1);
840 fread(address
, sizeof(address
), 1, fp
);
841 process
->current_function
= *address
;
844 fread(&tmpq
, sizeof(tmpq
), 1, fp
);
845 fread(&process
->usertrace
->cpu
, sizeof(process
->usertrace
->cpu
), 1, fp
);
857 /* Called because a HDR_PROCESS_STATE was found */
858 /* Append a saved state to the trace states */
859 void lttv_state_read_raw(LttvTraceState
*self
, FILE *fp
, GPtrArray
*quarktable
)
861 guint i
, nb_tracefile
, nb_block
, offset
;
863 LttvTracefileState
*tfcs
;
865 LttEventPosition
*ep
;
873 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
875 LttvAttributeValue value
;
876 GTree
*pqueue
= self
->parent
.ts_context
->pqueue
;
877 ep
= ltt_event_position_new();
879 restore_init_state(self
);
881 fread(&t
, sizeof(t
), 1, fp
);
884 if(feof(fp
) || ferror(fp
)) goto end_loop
;
886 if(hdr
== EOF
) goto end_loop
;
890 /* Call read_process_state_raw */
891 read_process_state_raw(self
, fp
, quarktable
);
901 case HDR_PROCESS_STATE
:
907 g_error("Error while parsing saved state file : unknown data header %d",
913 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
914 for(i
=0;i
<nb_cpus
;i
++) {
917 g_assert(hdr
== HDR_CPU
);
918 fread(&cpu_num
, sizeof(cpu_num
), 1, fp
); /* cpu number */
919 g_assert(i
== cpu_num
);
920 fread(&self
->running_process
[i
]->pid
,
921 sizeof(self
->running_process
[i
]->pid
), 1, fp
);
924 nb_tracefile
= self
->parent
.tracefiles
->len
;
926 for(i
= 0 ; i
< nb_tracefile
; i
++) {
928 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
929 LttvTracefileContext
*, i
));
930 // fprintf(fp, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
931 // tfcs->parent.timestamp.tv_sec,
932 // tfcs->parent.timestamp.tv_nsec);
933 g_tree_remove(pqueue
, &tfcs
->parent
);
935 g_assert(hdr
== HDR_TRACEFILE
);
936 fread(&tfcs
->parent
.timestamp
, sizeof(tfcs
->parent
.timestamp
), 1, fp
);
937 /* Note : if timestamp if LTT_TIME_INFINITE, there will be no
938 * position following : end of trace */
939 if(ltt_time_compare(tfcs
->parent
.timestamp
, ltt_time_infinite
) != 0) {
940 fread(&nb_block
, sizeof(nb_block
), 1, fp
);
941 fread(&offset
, sizeof(offset
), 1, fp
);
942 fread(&tsc
, sizeof(tsc
), 1, fp
);
943 ltt_event_position_set(ep
, tfcs
->parent
.tf
, nb_block
, offset
, tsc
);
944 gint ret
= ltt_tracefile_seek_position(tfcs
->parent
.tf
, ep
);
946 g_tree_insert(pqueue
, &tfcs
->parent
, &tfcs
->parent
);
951 saved_states_tree
= lttv_attribute_find_subdir(self
->parent
.t_a
,
952 LTTV_STATE_SAVED_STATES
);
953 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
954 value
= lttv_attribute_add(saved_states_tree
,
955 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
956 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
957 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
959 lttv_state_save(self
, saved_state_tree
);
960 g_debug("Saving state at time %lu.%lu", t
.tv_sec
,
963 *(self
->max_time_state_recomputed_in_seek
) = t
;
967 /* Called when a HDR_TRACE is found */
968 void lttv_trace_states_read_raw(LttvTraceState
*tcs
, FILE *fp
,
969 GPtrArray
*quarktable
)
974 if(feof(fp
) || ferror(fp
)) goto end_loop
;
976 if(hdr
== EOF
) goto end_loop
;
979 case HDR_PROCESS_STATE
:
980 /* Call read_process_state_raw */
981 lttv_state_read_raw(tcs
, fp
, quarktable
);
993 g_error("Error while parsing saved state file :"
994 " unexpected data header %d",
998 g_error("Error while parsing saved state file : unknown data header %d",
1003 *(tcs
->max_time_state_recomputed_in_seek
) = tcs
->parent
.time_span
.end_time
;
1004 restore_init_state(tcs
);
1005 lttv_process_trace_seek_time(tcs
, ltt_time_zero
);
1011 /* Copy each process from an existing hash table to a new one */
1013 static void copy_process_state(gpointer key
, gpointer value
,gpointer user_data
)
1015 LttvProcessState
*process
, *new_process
;
1017 GHashTable
*new_processes
= (GHashTable
*)user_data
;
1021 process
= (LttvProcessState
*)value
;
1022 new_process
= g_new(LttvProcessState
, 1);
1023 *new_process
= *process
;
1024 new_process
->execution_stack
= g_array_sized_new(FALSE
, FALSE
,
1025 sizeof(LttvExecutionState
), PREALLOCATED_EXECUTION_STACK
);
1026 new_process
->execution_stack
=
1027 g_array_set_size(new_process
->execution_stack
,
1028 process
->execution_stack
->len
);
1029 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
1030 g_array_index(new_process
->execution_stack
, LttvExecutionState
, i
) =
1031 g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
1033 new_process
->state
= &g_array_index(new_process
->execution_stack
,
1034 LttvExecutionState
, new_process
->execution_stack
->len
- 1);
1035 new_process
->user_stack
= g_array_sized_new(FALSE
, FALSE
,
1036 sizeof(guint64
), 0);
1037 new_process
->user_stack
=
1038 g_array_set_size(new_process
->user_stack
,
1039 process
->user_stack
->len
);
1040 for(i
= 0 ; i
< process
->user_stack
->len
; i
++) {
1041 g_array_index(new_process
->user_stack
, guint64
, i
) =
1042 g_array_index(process
->user_stack
, guint64
, i
);
1044 new_process
->current_function
= process
->current_function
;
1045 g_hash_table_insert(new_processes
, new_process
, new_process
);
1049 static GHashTable
*lttv_state_copy_process_table(GHashTable
*processes
)
1051 GHashTable
*new_processes
= g_hash_table_new(process_hash
, process_equal
);
1053 g_hash_table_foreach(processes
, copy_process_state
, new_processes
);
1054 return new_processes
;
1058 /* The saved state for each trace contains a member "processes", which
1059 stores a copy of the process table, and a member "tracefiles" with
1060 one entry per tracefile. Each tracefile has a "process" member pointing
1061 to the current process and a "position" member storing the tracefile
1062 position (needed to seek to the current "next" event. */
1064 static void state_save(LttvTraceState
*self
, LttvAttribute
*container
)
1066 guint i
, nb_tracefile
, nb_cpus
;
1068 LttvTracefileState
*tfcs
;
1070 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
1072 guint
*running_process
;
1074 LttvAttributeType type
;
1076 LttvAttributeValue value
;
1078 LttvAttributeName name
;
1080 LttEventPosition
*ep
;
1082 tracefiles_tree
= lttv_attribute_find_subdir(container
,
1083 LTTV_STATE_TRACEFILES
);
1085 value
= lttv_attribute_add(container
, LTTV_STATE_PROCESSES
,
1087 *(value
.v_pointer
) = lttv_state_copy_process_table(self
->processes
);
1089 /* Add the currently running processes array */
1090 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
1091 running_process
= g_new(guint
, nb_cpus
);
1092 for(i
=0;i
<nb_cpus
;i
++) {
1093 running_process
[i
] = self
->running_process
[i
]->pid
;
1095 value
= lttv_attribute_add(container
, LTTV_STATE_RUNNING_PROCESS
,
1097 *(value
.v_pointer
) = running_process
;
1099 g_info("State save");
1101 nb_tracefile
= self
->parent
.tracefiles
->len
;
1103 for(i
= 0 ; i
< nb_tracefile
; i
++) {
1105 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
1106 LttvTracefileContext
*, i
));
1107 tracefile_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
1108 value
= lttv_attribute_add(tracefiles_tree
, i
,
1110 *(value
.v_gobject
) = (GObject
*)tracefile_tree
;
1112 value
= lttv_attribute_add(tracefile_tree
, LTTV_STATE_PROCESS
,
1114 *(value
.v_uint
) = tfcs
->process
->pid
;
1116 value
= lttv_attribute_add(tracefile_tree
, LTTV_STATE_EVENT
,
1118 /* Only save the position if the tfs has not infinite time. */
1119 //if(!g_tree_lookup(self->parent.ts_context->pqueue, &tfcs->parent)
1120 // && current_tfcs != tfcs) {
1121 if(ltt_time_compare(tfcs
->parent
.timestamp
, ltt_time_infinite
) == 0) {
1122 *(value
.v_pointer
) = NULL
;
1124 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
1125 ep
= ltt_event_position_new();
1126 ltt_event_position(e
, ep
);
1127 *(value
.v_pointer
) = ep
;
1129 guint nb_block
, offset
;
1132 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
1133 g_info("Block %u offset %u tsc %llu time %lu.%lu", nb_block
, offset
,
1135 tfcs
->parent
.timestamp
.tv_sec
, tfcs
->parent
.timestamp
.tv_nsec
);
1141 static void state_restore(LttvTraceState
*self
, LttvAttribute
*container
)
1143 guint i
, nb_tracefile
, pid
, nb_cpus
;
1145 LttvTracefileState
*tfcs
;
1147 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
1149 guint
*running_process
;
1151 LttvAttributeType type
;
1153 LttvAttributeValue value
;
1155 LttvAttributeName name
;
1159 LttEventPosition
*ep
;
1161 LttvTracesetContext
*tsc
= self
->parent
.ts_context
;
1163 tracefiles_tree
= lttv_attribute_find_subdir(container
,
1164 LTTV_STATE_TRACEFILES
);
1166 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_PROCESSES
,
1168 g_assert(type
== LTTV_POINTER
);
1169 lttv_state_free_process_table(self
->processes
);
1170 self
->processes
= lttv_state_copy_process_table(*(value
.v_pointer
));
1172 /* Add the currently running processes array */
1173 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
1174 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RUNNING_PROCESS
,
1176 g_assert(type
== LTTV_POINTER
);
1177 running_process
= *(value
.v_pointer
);
1178 for(i
=0;i
<nb_cpus
;i
++) {
1179 pid
= running_process
[i
];
1180 self
->running_process
[i
] = lttv_state_find_process(self
, i
, pid
);
1181 g_assert(self
->running_process
[i
] != NULL
);
1185 nb_tracefile
= self
->parent
.tracefiles
->len
;
1187 //g_tree_destroy(tsc->pqueue);
1188 //tsc->pqueue = g_tree_new(compare_tracefile);
1190 for(i
= 0 ; i
< nb_tracefile
; i
++) {
1192 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
1193 LttvTracefileContext
*, i
));
1194 type
= lttv_attribute_get(tracefiles_tree
, i
, &name
, &value
, &is_named
);
1195 g_assert(type
== LTTV_GOBJECT
);
1196 tracefile_tree
= *((LttvAttribute
**)(value
.v_gobject
));
1198 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_PROCESS
,
1200 g_assert(type
== LTTV_UINT
);
1201 pid
= *(value
.v_uint
);
1202 tfcs
->process
= lttv_state_find_process_or_create(tfcs
, pid
);
1204 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_EVENT
,
1206 g_assert(type
== LTTV_POINTER
);
1207 //g_assert(*(value.v_pointer) != NULL);
1208 ep
= *(value
.v_pointer
);
1209 g_assert(tfcs
->parent
.t_context
!= NULL
);
1211 LttvTracefileContext
*tfc
= LTTV_TRACEFILE_CONTEXT(tfcs
);
1212 g_tree_remove(tsc
->pqueue
, tfc
);
1215 g_assert(ltt_tracefile_seek_position(tfc
->tf
, ep
) == 0);
1216 tfc
->timestamp
= ltt_event_time(ltt_tracefile_get_event(tfc
->tf
));
1217 g_assert(ltt_time_compare(tfc
->timestamp
, ltt_time_infinite
) != 0);
1218 g_tree_insert(tsc
->pqueue
, tfc
, tfc
);
1219 g_info("Restoring state for a tf at time %lu.%lu", tfc
->timestamp
.tv_sec
, tfc
->timestamp
.tv_nsec
);
1221 tfc
->timestamp
= ltt_time_infinite
;
1227 static void state_saved_free(LttvTraceState
*self
, LttvAttribute
*container
)
1229 guint i
, nb_tracefile
, nb_cpus
;
1231 LttvTracefileState
*tfcs
;
1233 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
1235 guint
*running_process
;
1237 LttvAttributeType type
;
1239 LttvAttributeValue value
;
1241 LttvAttributeName name
;
1245 LttEventPosition
*ep
;
1247 tracefiles_tree
= lttv_attribute_find_subdir(container
,
1248 LTTV_STATE_TRACEFILES
);
1249 g_object_ref(G_OBJECT(tracefiles_tree
));
1250 lttv_attribute_remove_by_name(container
, LTTV_STATE_TRACEFILES
);
1252 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_PROCESSES
,
1254 g_assert(type
== LTTV_POINTER
);
1255 lttv_state_free_process_table(*(value
.v_pointer
));
1256 *(value
.v_pointer
) = NULL
;
1257 lttv_attribute_remove_by_name(container
, LTTV_STATE_PROCESSES
);
1259 /* Free running processes array */
1260 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
1261 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RUNNING_PROCESS
,
1263 g_assert(type
== LTTV_POINTER
);
1264 running_process
= *(value
.v_pointer
);
1265 g_free(running_process
);
1267 nb_tracefile
= self
->parent
.tracefiles
->len
;
1269 for(i
= 0 ; i
< nb_tracefile
; i
++) {
1271 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
1272 LttvTracefileContext
*, i
));
1273 type
= lttv_attribute_get(tracefiles_tree
, i
, &name
, &value
, &is_named
);
1274 g_assert(type
== LTTV_GOBJECT
);
1275 tracefile_tree
= *((LttvAttribute
**)(value
.v_gobject
));
1277 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_EVENT
,
1279 g_assert(type
== LTTV_POINTER
);
1280 if(*(value
.v_pointer
) != NULL
) g_free(*(value
.v_pointer
));
1282 g_object_unref(G_OBJECT(tracefiles_tree
));
1286 static void free_saved_state(LttvTraceState
*self
)
1290 LttvAttributeType type
;
1292 LttvAttributeValue value
;
1294 LttvAttributeName name
;
1298 LttvAttribute
*saved_states
;
1300 saved_states
= lttv_attribute_find_subdir(self
->parent
.t_a
,
1301 LTTV_STATE_SAVED_STATES
);
1303 nb
= lttv_attribute_get_number(saved_states
);
1304 for(i
= 0 ; i
< nb
; i
++) {
1305 type
= lttv_attribute_get(saved_states
, i
, &name
, &value
, &is_named
);
1306 g_assert(type
== LTTV_GOBJECT
);
1307 state_saved_free(self
, *((LttvAttribute
**)value
.v_gobject
));
1310 lttv_attribute_remove_by_name(self
->parent
.t_a
, LTTV_STATE_SAVED_STATES
);
1315 create_max_time(LttvTraceState
*tcs
)
1317 LttvAttributeValue v
;
1319 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
1321 g_assert(*(v
.v_pointer
) == NULL
);
1322 *(v
.v_pointer
) = g_new(LttTime
,1);
1323 *((LttTime
*)*(v
.v_pointer
)) = ltt_time_zero
;
1328 get_max_time(LttvTraceState
*tcs
)
1330 LttvAttributeValue v
;
1332 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
1334 g_assert(*(v
.v_pointer
) != NULL
);
1335 tcs
->max_time_state_recomputed_in_seek
= (LttTime
*)*(v
.v_pointer
);
1340 free_max_time(LttvTraceState
*tcs
)
1342 LttvAttributeValue v
;
1344 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
1346 g_free(*(v
.v_pointer
));
1347 *(v
.v_pointer
) = NULL
;
1351 typedef struct _LttvNameTables
{
1352 // FIXME GQuark *eventtype_names;
1353 GQuark
*syscall_names
;
1359 GQuark
*soft_irq_names
;
1365 create_name_tables(LttvTraceState
*tcs
)
1369 GQuark f_name
, e_name
;
1373 LttvTraceHookByFacility
*thf
;
1379 GString
*fe_name
= g_string_new("");
1381 LttvNameTables
*name_tables
= g_new(LttvNameTables
, 1);
1383 LttvAttributeValue v
;
1385 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
1387 g_assert(*(v
.v_pointer
) == NULL
);
1388 *(v
.v_pointer
) = name_tables
;
1389 #if 0 // Use iteration over the facilities_by_name and then list all event
1390 // types of each facility
1391 nb
= ltt_trace_eventtype_number(tcs
->parent
.t
);
1392 name_tables
->eventtype_names
= g_new(GQuark
, nb
);
1393 for(i
= 0 ; i
< nb
; i
++) {
1394 et
= ltt_trace_eventtype_get(tcs
->parent
.t
, i
);
1395 e_name
= ltt_eventtype_name(et
);
1396 f_name
= ltt_facility_name(ltt_eventtype_facility(et
));
1397 g_string_printf(fe_name
, "%s.%s", f_name
, e_name
);
1398 name_tables
->eventtype_names
[i
] = g_quark_from_string(fe_name
->str
);
1401 if(!lttv_trace_find_hook(tcs
->parent
.t
,
1402 LTT_FACILITY_KERNEL_ARCH
, LTT_EVENT_SYSCALL_ENTRY
,
1403 LTT_FIELD_SYSCALL_ID
, 0, 0,
1406 thf
= lttv_trace_hook_get_first(&h
);
1408 t
= ltt_field_type(thf
->f1
);
1409 nb
= ltt_type_element_number(t
);
1411 lttv_trace_hook_destroy(&h
);
1413 name_tables
->syscall_names
= g_new(GQuark
, nb
);
1414 name_tables
->nb_syscalls
= nb
;
1416 for(i
= 0 ; i
< nb
; i
++) {
1417 name_tables
->syscall_names
[i
] = ltt_enum_string_get(t
, i
);
1420 //name_tables->syscall_names = g_new(GQuark, 256);
1421 //for(i = 0 ; i < 256 ; i++) {
1422 // g_string_printf(fe_name, "syscall %d", i);
1423 // name_tables->syscall_names[i] = g_quark_from_string(fe_name->str);
1426 name_tables
->syscall_names
= NULL
;
1427 name_tables
->nb_syscalls
= 0;
1430 if(!lttv_trace_find_hook(tcs
->parent
.t
, LTT_FACILITY_KERNEL
,
1431 LTT_EVENT_TRAP_ENTRY
,
1432 LTT_FIELD_TRAP_ID
, 0, 0,
1435 thf
= lttv_trace_hook_get_first(&h
);
1437 t
= ltt_field_type(thf
->f1
);
1438 //nb = ltt_type_element_number(t);
1440 lttv_trace_hook_destroy(&h
);
1443 name_tables->trap_names = g_new(GQuark, nb);
1444 for(i = 0 ; i < nb ; i++) {
1445 name_tables->trap_names[i] = g_quark_from_string(
1446 ltt_enum_string_get(t, i));
1449 name_tables
->nb_traps
= 256;
1450 name_tables
->trap_names
= g_new(GQuark
, 256);
1451 for(i
= 0 ; i
< 256 ; i
++) {
1452 g_string_printf(fe_name
, "trap %d", i
);
1453 name_tables
->trap_names
[i
] = g_quark_from_string(fe_name
->str
);
1456 name_tables
->trap_names
= NULL
;
1457 name_tables
->nb_traps
= 0;
1460 if(!lttv_trace_find_hook(tcs
->parent
.t
,
1461 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_ENTRY
,
1462 LTT_FIELD_IRQ_ID
, 0, 0,
1465 thf
= lttv_trace_hook_get_first(&h
);
1467 t
= ltt_field_type(thf
->f1
);
1468 //nb = ltt_type_element_number(t);
1470 lttv_trace_hook_destroy(&h
);
1473 name_tables->irq_names = g_new(GQuark, nb);
1474 for(i = 0 ; i < nb ; i++) {
1475 name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
1479 name_tables
->nb_irqs
= 256;
1480 name_tables
->irq_names
= g_new(GQuark
, 256);
1481 for(i
= 0 ; i
< 256 ; i
++) {
1482 g_string_printf(fe_name
, "irq %d", i
);
1483 name_tables
->irq_names
[i
] = g_quark_from_string(fe_name
->str
);
1486 name_tables
->nb_irqs
= 0;
1487 name_tables
->irq_names
= NULL
;
1490 name_tables->soft_irq_names = g_new(GQuark, nb);
1491 for(i = 0 ; i < nb ; i++) {
1492 name_tables->soft_irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
1496 name_tables
->nb_softirqs
= 256;
1497 name_tables
->soft_irq_names
= g_new(GQuark
, 256);
1498 for(i
= 0 ; i
< 256 ; i
++) {
1499 g_string_printf(fe_name
, "softirq %d", i
);
1500 name_tables
->soft_irq_names
[i
] = g_quark_from_string(fe_name
->str
);
1504 g_string_free(fe_name
, TRUE
);
1509 get_name_tables(LttvTraceState
*tcs
)
1511 LttvNameTables
*name_tables
;
1513 LttvAttributeValue v
;
1515 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
1517 g_assert(*(v
.v_pointer
) != NULL
);
1518 name_tables
= (LttvNameTables
*)*(v
.v_pointer
);
1519 //tcs->eventtype_names = name_tables->eventtype_names;
1520 tcs
->syscall_names
= name_tables
->syscall_names
;
1521 tcs
->nb_syscalls
= name_tables
->nb_syscalls
;
1522 tcs
->trap_names
= name_tables
->trap_names
;
1523 tcs
->nb_traps
= name_tables
->nb_traps
;
1524 tcs
->irq_names
= name_tables
->irq_names
;
1525 tcs
->soft_irq_names
= name_tables
->soft_irq_names
;
1526 tcs
->nb_irqs
= name_tables
->nb_irqs
;
1527 tcs
->nb_softirqs
= name_tables
->nb_softirqs
;
1532 free_name_tables(LttvTraceState
*tcs
)
1534 LttvNameTables
*name_tables
;
1536 LttvAttributeValue v
;
1538 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
1540 name_tables
= (LttvNameTables
*)*(v
.v_pointer
);
1541 *(v
.v_pointer
) = NULL
;
1543 // g_free(name_tables->eventtype_names);
1544 if(name_tables
->syscall_names
) g_free(name_tables
->syscall_names
);
1545 if(name_tables
->trap_names
) g_free(name_tables
->trap_names
);
1546 if(name_tables
->irq_names
) g_free(name_tables
->irq_names
);
1547 if(name_tables
->soft_irq_names
) g_free(name_tables
->soft_irq_names
);
1548 if(name_tables
) g_free(name_tables
);
1551 #ifdef HASH_TABLE_DEBUG
1553 static void test_process(gpointer key
, gpointer value
, gpointer user_data
)
1555 LttvProcessState
*process
= (LttvProcessState
*)value
;
1557 /* Test for process corruption */
1558 guint stack_len
= process
->execution_stack
->len
;
1561 static void hash_table_check(GHashTable
*table
)
1563 g_hash_table_foreach(table
, test_process
, NULL
);
1570 static void push_state(LttvTracefileState
*tfs
, LttvExecutionMode t
,
1573 LttvExecutionState
*es
;
1575 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
1576 guint cpu
= tfs
->cpu
;
1578 #ifdef HASH_TABLE_DEBUG
1579 hash_table_check(ts
->processes
);
1581 LttvProcessState
*process
= ts
->running_process
[cpu
];
1583 guint depth
= process
->execution_stack
->len
;
1585 process
->execution_stack
=
1586 g_array_set_size(process
->execution_stack
, depth
+ 1);
1589 &g_array_index(process
->execution_stack
, LttvExecutionState
, depth
- 1);
1591 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, depth
);
1594 es
->entry
= es
->change
= tfs
->parent
.timestamp
;
1595 es
->cum_cpu_time
= ltt_time_zero
;
1596 es
->s
= process
->state
->s
;
1597 process
->state
= es
;
1601 * return 1 when empty, else 0 */
1602 int lttv_state_pop_state_cleanup(LttvProcessState
*process
,
1603 LttvTracefileState
*tfs
)
1605 guint cpu
= tfs
->cpu
;
1606 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
1608 guint depth
= process
->execution_stack
->len
;
1614 process
->execution_stack
=
1615 g_array_set_size(process
->execution_stack
, depth
- 1);
1616 process
->state
= &g_array_index(process
->execution_stack
, LttvExecutionState
,
1618 process
->state
->change
= tfs
->parent
.timestamp
;
1623 static void pop_state(LttvTracefileState
*tfs
, LttvExecutionMode t
)
1625 guint cpu
= tfs
->cpu
;
1626 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
1627 LttvProcessState
*process
= ts
->running_process
[cpu
];
1629 guint depth
= process
->execution_stack
->len
;
1631 if(process
->state
->t
!= t
){
1632 g_info("Different execution mode type (%lu.%09lu): ignore it\n",
1633 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
1634 g_info("process state has %s when pop_int is %s\n",
1635 g_quark_to_string(process
->state
->t
),
1636 g_quark_to_string(t
));
1637 g_info("{ %u, %u, %s, %s, %s }\n",
1640 g_quark_to_string(process
->name
),
1641 g_quark_to_string(process
->brand
),
1642 g_quark_to_string(process
->state
->s
));
1647 g_info("Trying to pop last state on stack (%lu.%09lu): ignore it\n",
1648 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
1652 process
->execution_stack
=
1653 g_array_set_size(process
->execution_stack
, depth
- 1);
1654 process
->state
= &g_array_index(process
->execution_stack
, LttvExecutionState
,
1656 process
->state
->change
= tfs
->parent
.timestamp
;
1659 struct search_result
{
1660 const LttTime
*time
; /* Requested time */
1661 LttTime
*best
; /* Best result */
1664 static gint
search_usertrace(gconstpointer a
, gconstpointer b
)
1666 const LttTime
*elem_time
= (const LttTime
*)a
;
1667 /* Explicit non const cast */
1668 struct search_result
*res
= (struct search_result
*)b
;
1670 if(ltt_time_compare(*elem_time
, *(res
->time
)) < 0) {
1671 /* The usertrace was created before the schedchange */
1672 /* Get larger keys */
1674 } else if(ltt_time_compare(*elem_time
, *(res
->time
)) >= 0) {
1675 /* The usertrace was created after the schedchange time */
1676 /* Get smaller keys */
1678 if(ltt_time_compare(*elem_time
, *res
->best
) < 0) {
1679 res
->best
= elem_time
;
1682 res
->best
= elem_time
;
1689 static LttvTracefileState
*ltt_state_usertrace_find(LttvTraceState
*tcs
,
1690 guint pid
, const LttTime
*timestamp
)
1692 LttvTracefileState
*tfs
= NULL
;
1693 struct search_result res
;
1694 /* Find the usertrace associated with a pid and time interval.
1695 * Search in the usertraces by PID (within a hash) and then, for each
1696 * corresponding element of the array, find the first one with creation
1697 * timestamp the lowest, but higher or equal to "timestamp". */
1698 res
.time
= timestamp
;
1700 GTree
*usertrace_tree
= g_hash_table_lookup(tcs
->usertraces
, (gpointer
)pid
);
1701 if(usertrace_tree
) {
1702 g_tree_search(usertrace_tree
, search_usertrace
, &res
);
1704 tfs
= g_tree_lookup(usertrace_tree
, res
.best
);
1712 lttv_state_create_process(LttvTraceState
*tcs
, LttvProcessState
*parent
,
1713 guint cpu
, guint pid
, guint tgid
, GQuark name
, const LttTime
*timestamp
)
1715 LttvProcessState
*process
= g_new(LttvProcessState
, 1);
1717 LttvExecutionState
*es
;
1719 LttvTraceContext
*tc
= (LttvTraceContext
*)tcs
;
1724 process
->tgid
= tgid
;
1726 process
->name
= name
;
1727 process
->brand
= LTTV_STATE_UNBRANDED
;
1728 //process->last_cpu = tfs->cpu_name;
1729 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
1730 process
->type
= LTTV_STATE_USER_THREAD
;
1731 process
->usertrace
= ltt_state_usertrace_find(tcs
, pid
, timestamp
);
1732 process
->current_function
= 0; //function 0x0 by default.
1734 g_info("Process %u, core %p", process
->pid
, process
);
1735 g_hash_table_insert(tcs
->processes
, process
, process
);
1738 process
->ppid
= parent
->pid
;
1739 process
->creation_time
= *timestamp
;
1742 /* No parent. This process exists but we are missing all information about
1743 its creation. The birth time is set to zero but we remember the time of
1748 process
->creation_time
= ltt_time_zero
;
1751 process
->insertion_time
= *timestamp
;
1752 sprintf(buffer
,"%d-%lu.%lu",pid
, process
->creation_time
.tv_sec
,
1753 process
->creation_time
.tv_nsec
);
1754 process
->pid_time
= g_quark_from_string(buffer
);
1756 //process->last_cpu = tfs->cpu_name;
1757 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
1758 process
->execution_stack
= g_array_sized_new(FALSE
, FALSE
,
1759 sizeof(LttvExecutionState
), PREALLOCATED_EXECUTION_STACK
);
1760 process
->execution_stack
= g_array_set_size(process
->execution_stack
, 2);
1761 es
= process
->state
= &g_array_index(process
->execution_stack
,
1762 LttvExecutionState
, 0);
1763 es
->t
= LTTV_STATE_USER_MODE
;
1764 es
->n
= LTTV_STATE_SUBMODE_NONE
;
1765 es
->entry
= *timestamp
;
1766 //g_assert(timestamp->tv_sec != 0);
1767 es
->change
= *timestamp
;
1768 es
->cum_cpu_time
= ltt_time_zero
;
1769 es
->s
= LTTV_STATE_RUN
;
1771 es
= process
->state
= &g_array_index(process
->execution_stack
,
1772 LttvExecutionState
, 1);
1773 es
->t
= LTTV_STATE_SYSCALL
;
1774 es
->n
= LTTV_STATE_SUBMODE_NONE
;
1775 es
->entry
= *timestamp
;
1776 //g_assert(timestamp->tv_sec != 0);
1777 es
->change
= *timestamp
;
1778 es
->cum_cpu_time
= ltt_time_zero
;
1779 es
->s
= LTTV_STATE_WAIT_FORK
;
1781 /* Allocate an empty function call stack. If it's empty, use 0x0. */
1782 process
->user_stack
= g_array_sized_new(FALSE
, FALSE
,
1783 sizeof(guint64
), 0);
1788 LttvProcessState
*lttv_state_find_process(LttvTraceState
*ts
, guint cpu
,
1791 LttvProcessState key
;
1792 LttvProcessState
*process
;
1796 process
= g_hash_table_lookup(ts
->processes
, &key
);
1801 lttv_state_find_process_or_create(LttvTraceState
*ts
, guint cpu
, guint pid
,
1802 const LttTime
*timestamp
)
1804 LttvProcessState
*process
= lttv_state_find_process(ts
, cpu
, pid
);
1805 LttvExecutionState
*es
;
1807 /* Put ltt_time_zero creation time for unexisting processes */
1808 if(unlikely(process
== NULL
)) {
1809 process
= lttv_state_create_process(ts
,
1810 NULL
, cpu
, pid
, 0, LTTV_STATE_UNNAMED
, timestamp
);
1811 /* We are not sure is it's a kernel thread or normal thread, put the
1812 * bottom stack state to unknown */
1813 process
->execution_stack
=
1814 g_array_set_size(process
->execution_stack
, 1);
1815 process
->state
= es
=
1816 &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
1817 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
1822 /* FIXME : this function should be called when we receive an event telling that
1823 * release_task has been called in the kernel. In happens generally when
1824 * the parent waits for its child terminaison, but may also happen in special
1825 * cases in the child's exit : when the parent ignores its children SIGCCHLD or
1826 * has the flag SA_NOCLDWAIT. It can also happen when the child is part
1827 * of a killed thread ground, but isn't the leader.
1829 static void exit_process(LttvTracefileState
*tfs
, LttvProcessState
*process
)
1831 LttvTraceState
*ts
= LTTV_TRACE_STATE(tfs
->parent
.t_context
);
1832 LttvProcessState key
;
1834 key
.pid
= process
->pid
;
1835 key
.cpu
= process
->cpu
;
1836 g_hash_table_remove(ts
->processes
, &key
);
1837 g_array_free(process
->execution_stack
, TRUE
);
1838 g_array_free(process
->user_stack
, TRUE
);
1843 static void free_process_state(gpointer key
, gpointer value
,gpointer user_data
)
1845 g_array_free(((LttvProcessState
*)value
)->execution_stack
, TRUE
);
1846 g_array_free(((LttvProcessState
*)value
)->user_stack
, TRUE
);
1851 static void lttv_state_free_process_table(GHashTable
*processes
)
1853 g_hash_table_foreach(processes
, free_process_state
, NULL
);
1854 g_hash_table_destroy(processes
);
1858 static gboolean
syscall_entry(void *hook_data
, void *call_data
)
1860 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1862 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1863 LttvProcessState
*process
= ts
->running_process
[cpu
];
1864 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1865 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1866 LttField
*f
= thf
->f1
;
1868 LttvExecutionSubmode submode
;
1870 guint nb_syscalls
= ((LttvTraceState
*)(s
->parent
.t_context
))->nb_syscalls
;
1871 guint syscall
= ltt_event_get_unsigned(e
, f
);
1873 if(syscall
< nb_syscalls
) {
1874 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->syscall_names
[
1877 /* Fixup an incomplete syscall table */
1878 GString
*string
= g_string_new("");
1879 g_string_printf(string
, "syscall %u", syscall
);
1880 submode
= g_quark_from_string(string
->str
);
1881 g_string_free(string
, TRUE
);
1883 /* There can be no system call from PID 0 : unknown state */
1884 if(process
->pid
!= 0)
1885 push_state(s
, LTTV_STATE_SYSCALL
, submode
);
1890 static gboolean
syscall_exit(void *hook_data
, void *call_data
)
1892 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1894 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
1895 LttvProcessState
*process
= ts
->running_process
[cpu
];
1897 /* There can be no system call from PID 0 : unknown state */
1898 if(process
->pid
!= 0)
1899 pop_state(s
, LTTV_STATE_SYSCALL
);
1904 static gboolean
trap_entry(void *hook_data
, void *call_data
)
1906 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1907 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1908 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1909 LttField
*f
= thf
->f1
;
1911 LttvExecutionSubmode submode
;
1913 guint64 nb_traps
= ((LttvTraceState
*)(s
->parent
.t_context
))->nb_traps
;
1914 guint64 trap
= ltt_event_get_long_unsigned(e
, f
);
1916 if(trap
< nb_traps
) {
1917 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->trap_names
[trap
];
1919 /* Fixup an incomplete trap table */
1920 GString
*string
= g_string_new("");
1921 g_string_printf(string
, "trap %llu", trap
);
1922 submode
= g_quark_from_string(string
->str
);
1923 g_string_free(string
, TRUE
);
1926 push_state(s
, LTTV_STATE_TRAP
, submode
);
1931 static gboolean
trap_exit(void *hook_data
, void *call_data
)
1933 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1935 pop_state(s
, LTTV_STATE_TRAP
);
1940 static gboolean
irq_entry(void *hook_data
, void *call_data
)
1942 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1943 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1944 guint8 fac_id
= ltt_event_facility_id(e
);
1945 guint8 ev_id
= ltt_event_eventtype_id(e
);
1946 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1947 // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
1948 g_assert(thf
->f1
!= NULL
);
1949 // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
1950 LttField
*f
= thf
->f1
;
1952 LttvExecutionSubmode submode
;
1953 guint64 irq
= ltt_event_get_unsigned(e
, f
);
1954 guint64 nb_irqs
= ((LttvTraceState
*)(s
->parent
.t_context
))->nb_irqs
;
1958 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->irq_names
[irq
];
1960 /* Fixup an incomplete irq table */
1961 GString
*string
= g_string_new("");
1962 g_string_printf(string
, "irq %llu", irq
);
1963 submode
= g_quark_from_string(string
->str
);
1964 g_string_free(string
, TRUE
);
1967 /* Do something with the info about being in user or system mode when int? */
1968 push_state(s
, LTTV_STATE_IRQ
, submode
);
1972 static gboolean
soft_irq_exit(void *hook_data
, void *call_data
)
1974 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1976 pop_state(s
, LTTV_STATE_SOFT_IRQ
);
1982 static gboolean
irq_exit(void *hook_data
, void *call_data
)
1984 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1986 pop_state(s
, LTTV_STATE_IRQ
);
1990 static gboolean
soft_irq_entry(void *hook_data
, void *call_data
)
1992 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
1993 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
1994 guint8 fac_id
= ltt_event_facility_id(e
);
1995 guint8 ev_id
= ltt_event_eventtype_id(e
);
1996 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
1997 // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
1998 g_assert(thf
->f1
!= NULL
);
1999 // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
2000 LttField
*f
= thf
->f1
;
2002 LttvExecutionSubmode submode
;
2003 guint64 softirq
= ltt_event_get_unsigned(e
, f
);
2004 guint64 nb_softirqs
= ((LttvTraceState
*)(s
->parent
.t_context
))->nb_softirqs
;
2007 if(softirq
< nb_softirqs
) {
2008 submode
= ((LttvTraceState
*)(s
->parent
.t_context
))->soft_irq_names
[softirq
];
2010 /* Fixup an incomplete irq table */
2011 GString
*string
= g_string_new("");
2012 g_string_printf(string
, "softirq %llu", softirq
);
2013 submode
= g_quark_from_string(string
->str
);
2014 g_string_free(string
, TRUE
);
2017 /* Do something with the info about being in user or system mode when int? */
2018 push_state(s
, LTTV_STATE_SOFT_IRQ
, submode
);
2022 static void push_function(LttvTracefileState
*tfs
, guint64 funcptr
)
2026 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
2027 guint cpu
= tfs
->cpu
;
2028 LttvProcessState
*process
= ts
->running_process
[cpu
];
2030 guint depth
= process
->user_stack
->len
;
2032 process
->user_stack
=
2033 g_array_set_size(process
->user_stack
, depth
+ 1);
2035 new_func
= &g_array_index(process
->user_stack
, guint64
, depth
);
2036 *new_func
= funcptr
;
2037 process
->current_function
= funcptr
;
2040 static void pop_function(LttvTracefileState
*tfs
, guint64 funcptr
)
2042 guint cpu
= tfs
->cpu
;
2043 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
2044 LttvProcessState
*process
= ts
->running_process
[cpu
];
2046 if(process
->current_function
!= funcptr
){
2047 g_info("Different functions (%lu.%09lu): ignore it\n",
2048 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
2049 g_info("process state has %llu when pop_function is %llu\n",
2050 process
->current_function
, funcptr
);
2051 g_info("{ %u, %u, %s, %s, %s }\n",
2054 g_quark_to_string(process
->name
),
2055 g_quark_to_string(process
->brand
),
2056 g_quark_to_string(process
->state
->s
));
2059 guint depth
= process
->user_stack
->len
;
2062 g_info("Trying to pop last function on stack (%lu.%09lu): ignore it\n",
2063 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
2067 process
->user_stack
=
2068 g_array_set_size(process
->user_stack
, depth
- 1);
2069 process
->current_function
=
2070 g_array_index(process
->user_stack
, guint64
, depth
- 2);
2074 static gboolean
function_entry(void *hook_data
, void *call_data
)
2076 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2077 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2078 guint8 fac_id
= ltt_event_facility_id(e
);
2079 guint8 ev_id
= ltt_event_eventtype_id(e
);
2080 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2081 g_assert(thf
->f1
!= NULL
);
2082 LttField
*f
= thf
->f1
;
2083 guint64 funcptr
= ltt_event_get_long_unsigned(e
, f
);
2085 push_function(s
, funcptr
);
2089 static gboolean
function_exit(void *hook_data
, void *call_data
)
2091 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2092 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2093 guint8 fac_id
= ltt_event_facility_id(e
);
2094 guint8 ev_id
= ltt_event_eventtype_id(e
);
2095 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2096 g_assert(thf
->f1
!= NULL
);
2097 LttField
*f
= thf
->f1
;
2098 guint64 funcptr
= ltt_event_get_long_unsigned(e
, f
);
2100 LttvExecutionSubmode submode
;
2102 pop_function(s
, funcptr
);
2106 static gboolean
schedchange(void *hook_data
, void *call_data
)
2108 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2110 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2111 LttvProcessState
*process
= ts
->running_process
[cpu
];
2112 LttvProcessState
*old_process
= ts
->running_process
[cpu
];
2114 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2115 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2116 guint pid_in
, pid_out
;
2119 pid_out
= ltt_event_get_unsigned(e
, thf
->f1
);
2120 pid_in
= ltt_event_get_unsigned(e
, thf
->f2
);
2121 state_out
= ltt_event_get_int(e
, thf
->f3
);
2123 if(likely(process
!= NULL
)) {
2125 /* We could not know but it was not the idle process executing.
2126 This should only happen at the beginning, before the first schedule
2127 event, and when the initial information (current process for each CPU)
2128 is missing. It is not obvious how we could, after the fact, compensate
2129 the wrongly attributed statistics. */
2131 //This test only makes sense once the state is known and if there is no
2132 //missing events. We need to silently ignore schedchange coming after a
2133 //process_free, or it causes glitches. (FIXME)
2134 //if(unlikely(process->pid != pid_out)) {
2135 // g_assert(process->pid == 0);
2137 if(process
->pid
== 0 && process
->state
->t
== LTTV_STATE_MODE_UNKNOWN
) {
2138 /* Scheduling out of pid 0 at beginning of the trace :
2139 * we know for sure it is in syscall mode at this point. */
2140 g_assert(process
->execution_stack
->len
== 1);
2141 process
->state
->t
= LTTV_STATE_SYSCALL
;
2143 if(unlikely(process
->state
->s
== LTTV_STATE_EXIT
)) {
2144 process
->state
->s
= LTTV_STATE_ZOMBIE
;
2145 process
->state
->change
= s
->parent
.timestamp
;
2147 if(unlikely(state_out
== 0)) process
->state
->s
= LTTV_STATE_WAIT_CPU
;
2148 else process
->state
->s
= LTTV_STATE_WAIT
;
2149 process
->state
->change
= s
->parent
.timestamp
;
2153 exit_process(s
, process
); /* EXIT_DEAD */
2154 /* see sched.h for states */
2156 process
= ts
->running_process
[cpu
] =
2157 lttv_state_find_process_or_create(
2158 (LttvTraceState
*)s
->parent
.t_context
,
2160 &s
->parent
.timestamp
);
2161 process
->state
->s
= LTTV_STATE_RUN
;
2163 if(process
->usertrace
)
2164 process
->usertrace
->cpu
= cpu
;
2165 // process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)s)->tf);
2166 process
->state
->change
= s
->parent
.timestamp
;
2170 static gboolean
process_fork(void *hook_data
, void *call_data
)
2172 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2173 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2174 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2176 guint child_pid
; /* In the Linux Kernel, there is one PID per thread. */
2177 guint child_tgid
; /* tgid in the Linux kernel is the "real" POSIX PID. */
2178 LttvProcessState
*zombie_process
;
2180 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2181 LttvProcessState
*process
= ts
->running_process
[cpu
];
2182 LttvProcessState
*child_process
;
2185 parent_pid
= ltt_event_get_unsigned(e
, thf
->f1
);
2188 child_pid
= ltt_event_get_unsigned(e
, thf
->f2
);
2189 s
->parent
.target_pid
= child_pid
;
2192 if(thf
->f3
) child_tgid
= ltt_event_get_unsigned(e
, thf
->f3
);
2193 else child_tgid
= 0;
2195 /* Mathieu : it seems like the process might have been scheduled in before the
2196 * fork, and, in a rare case, might be the current process. This might happen
2197 * in a SMP case where we don't have enough precision on the clocks.
2199 * Test reenabled after precision fixes on time. (Mathieu) */
2201 zombie_process
= lttv_state_find_process(ts
, ANY_CPU
, child_pid
);
2203 if(unlikely(zombie_process
!= NULL
)) {
2204 /* Reutilisation of PID. Only now we are sure that the old PID
2205 * has been released. FIXME : should know when release_task happens instead.
2207 guint num_cpus
= ltt_trace_get_num_cpu(ts
->parent
.t
);
2209 for(i
=0; i
< num_cpus
; i
++) {
2210 g_assert(zombie_process
!= ts
->running_process
[i
]);
2213 exit_process(s
, zombie_process
);
2216 g_assert(process
->pid
!= child_pid
);
2217 // FIXME : Add this test in the "known state" section
2218 // g_assert(process->pid == parent_pid);
2219 child_process
= lttv_state_find_process(ts
, ANY_CPU
, child_pid
);
2220 if(child_process
== NULL
) {
2221 child_process
= lttv_state_create_process(ts
, process
, cpu
,
2222 child_pid
, child_tgid
,
2223 LTTV_STATE_UNNAMED
, &s
->parent
.timestamp
);
2225 /* The process has already been created : due to time imprecision between
2226 * multiple CPUs : it has been scheduled in before creation. Note that we
2227 * shouldn't have this kind of imprecision.
2229 * Simply put a correct parent.
2231 g_assert(0); /* This is a problematic case : the process has been created
2232 before the fork event */
2233 child_process
->ppid
= process
->pid
;
2234 child_process
->tgid
= child_tgid
;
2236 g_assert(child_process
->name
== LTTV_STATE_UNNAMED
);
2237 child_process
->name
= process
->name
;
2238 child_process
->brand
= process
->brand
;
2243 /* We stamp a newly created process as kernel_thread */
2244 static gboolean
process_kernel_thread(void *hook_data
, void *call_data
)
2246 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2247 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2248 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2251 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2252 LttvProcessState
*process
;
2253 LttvExecutionState
*es
;
2256 pid
= ltt_event_get_unsigned(e
, thf
->f1
);
2257 s
->parent
.target_pid
= pid
;
2259 process
= lttv_state_find_process(ts
, ANY_CPU
, pid
);
2260 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
2261 es
->t
= LTTV_STATE_SYSCALL
;
2262 process
->type
= LTTV_STATE_KERNEL_THREAD
;
2267 static gboolean
process_exit(void *hook_data
, void *call_data
)
2269 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2270 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2271 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2275 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2276 LttvProcessState
*process
; // = ts->running_process[cpu];
2278 pid
= ltt_event_get_unsigned(e
, thf
->f1
);
2279 s
->parent
.target_pid
= pid
;
2281 // FIXME : Add this test in the "known state" section
2282 // g_assert(process->pid == pid);
2284 process
= lttv_state_find_process(ts
, ANY_CPU
, pid
);
2285 if(likely(process
!= NULL
)) {
2286 process
->state
->s
= LTTV_STATE_EXIT
;
2291 static gboolean
process_free(void *hook_data
, void *call_data
)
2293 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2294 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2295 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2296 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2298 LttvProcessState
*process
;
2300 /* PID of the process to release */
2301 release_pid
= ltt_event_get_unsigned(e
, thf
->f1
);
2302 s
->parent
.target_pid
= release_pid
;
2304 g_assert(release_pid
!= 0);
2306 process
= lttv_state_find_process(ts
, ANY_CPU
, release_pid
);
2308 if(likely(process
!= NULL
)) {
2309 /* release_task is happening at kernel level : we can now safely release
2310 * the data structure of the process */
2311 //This test is fun, though, as it may happen that
2312 //at time t : CPU 0 : process_free
2313 //at time t+150ns : CPU 1 : schedule out
2314 //Clearly due to time imprecision, we disable it. (Mathieu)
2315 //If this weird case happen, we have no choice but to put the
2316 //Currently running process on the cpu to 0.
2317 //I re-enable it following time precision fixes. (Mathieu)
2318 //Well, in the case where an process is freed by a process on another CPU
2319 //and still scheduled, it happens that this is the schedchange that will
2320 //drop the last reference count. Do not free it here!
2321 guint num_cpus
= ltt_trace_get_num_cpu(ts
->parent
.t
);
2323 for(i
=0; i
< num_cpus
; i
++) {
2324 //g_assert(process != ts->running_process[i]);
2325 if(process
== ts
->running_process
[i
]) {
2326 //ts->running_process[i] = lttv_state_find_process(ts, i, 0);
2330 if(i
== num_cpus
) /* process is not scheduled */
2331 exit_process(s
, process
);
2338 static gboolean
process_exec(void *hook_data
, void *call_data
)
2340 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2341 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2342 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2343 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2346 LttvProcessState
*process
= ts
->running_process
[cpu
];
2348 /* PID of the process to release */
2349 guint64 name_len
= ltt_event_field_element_number(e
, thf
->f1
);
2350 //name = ltt_event_get_string(e, thf->f1);
2351 LttField
*child
= ltt_event_field_element_select(e
, thf
->f1
, 0);
2353 (gchar
*)(ltt_event_data(e
)+ltt_event_field_offset(e
, child
));
2354 gchar
*null_term_name
= g_new(gchar
, name_len
+1);
2355 memcpy(null_term_name
, name_begin
, name_len
);
2356 null_term_name
[name_len
] = '\0';
2358 process
->name
= g_quark_from_string(null_term_name
);
2359 process
->brand
= LTTV_STATE_UNBRANDED
;
2360 g_free(null_term_name
);
2364 static gboolean
thread_brand(void *hook_data
, void *call_data
)
2366 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2367 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2368 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2369 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2372 LttvProcessState
*process
= ts
->running_process
[cpu
];
2374 name
= ltt_event_get_string(e
, thf
->f1
);
2375 process
->brand
= g_quark_from_string(name
);
2380 static void fix_process(gpointer key
, gpointer value
,
2383 LttvProcessState
*process
;
2384 LttvExecutionState
*es
;
2385 process
= (LttvProcessState
*)value
;
2386 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)user_data
;
2387 LttTime
*timestamp
= (LttTime
*)user_data
;
2389 if(process
->type
== LTTV_STATE_KERNEL_THREAD
) {
2390 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
2391 if(es
->t
== LTTV_STATE_MODE_UNKNOWN
) {
2392 es
->t
= LTTV_STATE_SYSCALL
;
2393 es
->s
= LTTV_STATE_WAIT
;
2394 es
->n
= LTTV_STATE_SUBMODE_NONE
;
2395 es
->entry
= *timestamp
;
2396 es
->change
= *timestamp
;
2397 es
->cum_cpu_time
= ltt_time_zero
;
2400 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
2401 if(es
->t
== LTTV_STATE_MODE_UNKNOWN
) {
2402 es
->t
= LTTV_STATE_USER_MODE
;
2403 es
->n
= LTTV_STATE_SUBMODE_NONE
;
2404 es
->entry
= *timestamp
;
2405 //g_assert(timestamp->tv_sec != 0);
2406 es
->change
= *timestamp
;
2407 es
->cum_cpu_time
= ltt_time_zero
;
2408 es
->s
= LTTV_STATE_RUN
;
2410 if(process
->execution_stack
->len
== 1) {
2411 /* Still in user mode, means never scheduled */
2412 process
->execution_stack
=
2413 g_array_set_size(process
->execution_stack
, 2);
2414 es
= process
->state
= &g_array_index(process
->execution_stack
,
2415 LttvExecutionState
, 1);
2416 es
->t
= LTTV_STATE_SYSCALL
;
2417 es
->n
= LTTV_STATE_SUBMODE_NONE
;
2418 es
->entry
= *timestamp
;
2419 //g_assert(timestamp->tv_sec != 0);
2420 es
->change
= *timestamp
;
2421 es
->cum_cpu_time
= ltt_time_zero
;
2422 es
->s
= LTTV_STATE_WAIT
;
2428 static gboolean
statedump_end(void *hook_data
, void *call_data
)
2430 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2431 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2432 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
2433 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2434 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2436 /* For all processes */
2437 /* if kernel thread, if stack[0] is unknown, set to syscall mode, wait */
2438 /* else, if stack[0] is unknown, set to user mode, running */
2440 g_hash_table_foreach(ts
->processes
, fix_process
, &tfc
->timestamp
);
2443 static gboolean
enum_process_state(void *hook_data
, void *call_data
)
2445 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2446 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2447 //It's slow : optimise later by doing this before reading trace.
2448 LttEventType
*et
= ltt_event_eventtype(e
);
2450 LttvTraceHookByFacility
*thf
= (LttvTraceHookByFacility
*)hook_data
;
2456 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2457 LttvProcessState
*process
= ts
->running_process
[cpu
];
2458 LttvProcessState
*parent_process
;
2459 LttField
*f4
, *f5
, *f6
, *f7
, *f8
;
2460 GQuark type
, mode
, submode
, status
;
2461 LttvExecutionState
*es
;
2464 pid
= ltt_event_get_unsigned(e
, thf
->f1
);
2465 s
->parent
.target_pid
= pid
;
2468 parent_pid
= ltt_event_get_unsigned(e
, thf
->f2
);
2471 command
= ltt_event_get_string(e
, thf
->f3
);
2474 f4
= ltt_eventtype_field_by_name(et
, LTT_FIELD_TYPE
);
2475 type
= ltt_enum_string_get(ltt_field_type(f4
),
2476 ltt_event_get_unsigned(e
, f4
));
2479 f5
= ltt_eventtype_field_by_name(et
, LTT_FIELD_MODE
);
2480 mode
= ltt_enum_string_get(ltt_field_type(f5
),
2481 ltt_event_get_unsigned(e
, f5
));
2484 f6
= ltt_eventtype_field_by_name(et
, LTT_FIELD_SUBMODE
);
2485 submode
= ltt_enum_string_get(ltt_field_type(f6
),
2486 ltt_event_get_unsigned(e
, f6
));
2489 f7
= ltt_eventtype_field_by_name(et
, LTT_FIELD_STATUS
);
2490 status
= ltt_enum_string_get(ltt_field_type(f7
),
2491 ltt_event_get_unsigned(e
, f7
));
2494 f8
= ltt_eventtype_field_by_name(et
, LTT_FIELD_TGID
);
2495 if(f8
) tgid
= ltt_event_get_unsigned(e
, f8
);
2498 /* The process might exist if a process was forked while performing the state
2500 process
= lttv_state_find_process(ts
, ANY_CPU
, pid
);
2501 if(process
== NULL
) {
2502 parent_process
= lttv_state_find_process(ts
, ANY_CPU
, parent_pid
);
2503 process
= lttv_state_create_process(ts
, parent_process
, cpu
,
2504 pid
, tgid
, g_quark_from_string(command
),
2505 &s
->parent
.timestamp
);
2507 /* Keep the stack bottom : a running user mode */
2508 /* Disabled because of inconsistencies in the current statedump states. */
2509 if(type
== LTTV_STATE_KERNEL_THREAD
) {
2510 /* Only keep the bottom
2511 * FIXME Kernel thread : can be in syscall or interrupt or trap. */
2512 /* Will cause expected trap when in fact being syscall (even after end of
2514 * Will cause expected interrupt when being syscall. (only before end of
2515 * statedump event) */
2516 // This will cause a "popping last state on stack, ignoring it."
2517 process
->execution_stack
= g_array_set_size(process
->execution_stack
, 1);
2518 es
= process
->state
= &g_array_index(process
->execution_stack
,
2519 LttvExecutionState
, 0);
2520 process
->type
= LTTV_STATE_KERNEL_THREAD
;
2521 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
2522 es
->s
= LTTV_STATE_UNNAMED
;
2523 es
->n
= LTTV_STATE_SUBMODE_UNKNOWN
;
2525 es
->t
= LTTV_STATE_SYSCALL
;
2530 /* User space process :
2531 * bottom : user mode
2532 * either currently running or scheduled out.
2533 * can be scheduled out because interrupted in (user mode or in syscall)
2534 * or because of an explicit call to the scheduler in syscall. Note that
2535 * the scheduler call comes after the irq_exit, so never in interrupt
2537 // temp workaround : set size to 1 : only have user mode bottom of stack.
2538 // will cause g_info message of expected syscall mode when in fact being
2539 // in user mode. Can also cause expected trap when in fact being user
2540 // mode in the event of a page fault reenabling interrupts in the handler.
2541 // Expected syscall and trap can also happen after the end of statedump
2542 // This will cause a "popping last state on stack, ignoring it."
2543 process
->execution_stack
= g_array_set_size(process
->execution_stack
, 1);
2544 es
= process
->state
= &g_array_index(process
->execution_stack
,
2545 LttvExecutionState
, 0);
2546 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
2547 es
->s
= LTTV_STATE_UNNAMED
;
2548 es
->n
= LTTV_STATE_SUBMODE_UNKNOWN
;
2550 es
->t
= LTTV_STATE_USER_MODE
;
2558 es
= process
->state
= &g_array_index(process
->execution_stack
,
2559 LttvExecutionState
, 1);
2560 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
2561 es
->s
= LTTV_STATE_UNNAMED
;
2562 es
->n
= LTTV_STATE_SUBMODE_UNKNOWN
;
2566 /* The process has already been created :
2567 * Probably was forked while dumping the process state or
2568 * was simply scheduled in prior to get the state dump event.
2569 * We know for sure if it is a user space thread.
2571 process
->ppid
= parent_pid
;
2572 process
->tgid
= tgid
;
2573 process
->name
= g_quark_from_string(command
);
2575 &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
2576 if(type
!= LTTV_STATE_KERNEL_THREAD
)
2577 es
->t
= LTTV_STATE_USER_MODE
;
2578 /* Don't mess around with the stack, it will eventually become
2579 * ok after the end of state dump. */
2585 gint
lttv_state_hook_add_event_hooks(void *hook_data
, void *call_data
)
2587 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
2589 lttv_state_add_event_hooks(tss
);
2594 void lttv_state_add_event_hooks(LttvTracesetState
*self
)
2596 LttvTraceset
*traceset
= self
->parent
.ts
;
2598 guint i
, j
, k
, l
, nb_trace
, nb_tracefile
;
2602 LttvTracefileState
*tfs
;
2606 LttvTraceHookByFacility
*thf
;
2608 LttvTraceHook
*hook
;
2610 LttvAttributeValue val
;
2615 nb_trace
= lttv_traceset_number(traceset
);
2616 for(i
= 0 ; i
< nb_trace
; i
++) {
2617 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
2619 /* Find the eventtype id for the following events and register the
2620 associated by id hooks. */
2622 hooks
= g_array_sized_new(FALSE
, FALSE
, sizeof(LttvTraceHook
), 19);
2623 hooks
= g_array_set_size(hooks
, 19); // Max possible number of hooks.
2626 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2627 LTT_FACILITY_KERNEL_ARCH
, LTT_EVENT_SYSCALL_ENTRY
,
2628 LTT_FIELD_SYSCALL_ID
, 0, 0,
2629 syscall_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2632 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2633 LTT_FACILITY_KERNEL_ARCH
, LTT_EVENT_SYSCALL_EXIT
,
2635 syscall_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2638 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2639 LTT_FACILITY_KERNEL
, LTT_EVENT_TRAP_ENTRY
,
2640 LTT_FIELD_TRAP_ID
, 0, 0,
2641 trap_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2644 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2645 LTT_FACILITY_KERNEL
, LTT_EVENT_TRAP_EXIT
,
2647 trap_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2650 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2651 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_ENTRY
,
2652 LTT_FIELD_IRQ_ID
, 0, 0,
2653 irq_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2656 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2657 LTT_FACILITY_KERNEL
, LTT_EVENT_IRQ_EXIT
,
2659 irq_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2662 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2663 LTT_FACILITY_KERNEL
, LTT_EVENT_SOFT_IRQ_ENTRY
,
2664 LTT_FIELD_SOFT_IRQ_ID
, 0, 0,
2665 soft_irq_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2668 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2669 LTT_FACILITY_KERNEL
, LTT_EVENT_SOFT_IRQ_EXIT
,
2671 soft_irq_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2674 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2675 LTT_FACILITY_PROCESS
, LTT_EVENT_SCHEDCHANGE
,
2676 LTT_FIELD_OUT
, LTT_FIELD_IN
, LTT_FIELD_OUT_STATE
,
2677 schedchange
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2680 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2681 LTT_FACILITY_PROCESS
, LTT_EVENT_FORK
,
2682 LTT_FIELD_PARENT_PID
, LTT_FIELD_CHILD_PID
, LTT_FIELD_TGID
,
2683 process_fork
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2686 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2687 LTT_FACILITY_PROCESS
, LTT_EVENT_KERNEL_THREAD
,
2688 LTT_FIELD_PID
, 0, 0,
2689 process_kernel_thread
, NULL
, &g_array_index(hooks
, LttvTraceHook
,
2693 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2694 LTT_FACILITY_PROCESS
, LTT_EVENT_EXIT
,
2695 LTT_FIELD_PID
, 0, 0,
2696 process_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2699 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2700 LTT_FACILITY_PROCESS
, LTT_EVENT_FREE
,
2701 LTT_FIELD_PID
, 0, 0,
2702 process_free
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2705 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2706 LTT_FACILITY_FS
, LTT_EVENT_EXEC
,
2707 LTT_FIELD_FILENAME
, 0, 0,
2708 process_exec
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2711 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2712 LTT_FACILITY_USER_GENERIC
, LTT_EVENT_THREAD_BRAND
,
2713 LTT_FIELD_NAME
, 0, 0,
2714 thread_brand
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2717 /* statedump-related hooks */
2718 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2719 LTT_FACILITY_STATEDUMP
, LTT_EVENT_ENUM_PROCESS_STATE
,
2720 LTT_FIELD_PID
, LTT_FIELD_PARENT_PID
, LTT_FIELD_NAME
,
2721 enum_process_state
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2724 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2725 LTT_FACILITY_STATEDUMP
, LTT_EVENT_STATEDUMP_END
,
2727 statedump_end
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2730 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2731 LTT_FACILITY_USER_GENERIC
, LTT_EVENT_FUNCTION_ENTRY
,
2732 LTT_FIELD_THIS_FN
, LTT_FIELD_CALL_SITE
, 0,
2733 function_entry
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2736 ret
= lttv_trace_find_hook(ts
->parent
.t
,
2737 LTT_FACILITY_USER_GENERIC
, LTT_EVENT_FUNCTION_EXIT
,
2738 LTT_FIELD_THIS_FN
, LTT_FIELD_CALL_SITE
, 0,
2739 function_exit
, NULL
, &g_array_index(hooks
, LttvTraceHook
, hn
++));
2742 hooks
= g_array_set_size(hooks
, hn
);
2744 /* Add these hooks to each event_by_id hooks list */
2746 nb_tracefile
= ts
->parent
.tracefiles
->len
;
2748 for(j
= 0 ; j
< nb_tracefile
; j
++) {
2750 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
2751 LttvTracefileContext
*, j
));
2753 for(k
= 0 ; k
< hooks
->len
; k
++) {
2754 hook
= &g_array_index(hooks
, LttvTraceHook
, k
);
2755 for(l
=0;l
<hook
->fac_list
->len
;l
++) {
2756 thf
= g_array_index(hook
->fac_list
, LttvTraceHookByFacility
*, l
);
2758 lttv_hooks_by_id_find(tfs
->parent
.event_by_id
, thf
->id
),
2765 lttv_attribute_find(ts
->parent
.a
, LTTV_STATE_HOOKS
, LTTV_POINTER
, &val
);
2766 *(val
.v_pointer
) = hooks
;
2770 gint
lttv_state_hook_remove_event_hooks(void *hook_data
, void *call_data
)
2772 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
2774 lttv_state_remove_event_hooks(tss
);
2779 void lttv_state_remove_event_hooks(LttvTracesetState
*self
)
2781 LttvTraceset
*traceset
= self
->parent
.ts
;
2783 guint i
, j
, k
, l
, nb_trace
, nb_tracefile
;
2787 LttvTracefileState
*tfs
;
2791 LttvTraceHook
*hook
;
2793 LttvTraceHookByFacility
*thf
;
2795 LttvAttributeValue val
;
2797 nb_trace
= lttv_traceset_number(traceset
);
2798 for(i
= 0 ; i
< nb_trace
; i
++) {
2799 ts
= LTTV_TRACE_STATE(self
->parent
.traces
[i
]);
2801 lttv_attribute_find(ts
->parent
.a
, LTTV_STATE_HOOKS
, LTTV_POINTER
, &val
);
2802 hooks
= *(val
.v_pointer
);
2804 /* Remove these hooks from each event_by_id hooks list */
2806 nb_tracefile
= ts
->parent
.tracefiles
->len
;
2808 for(j
= 0 ; j
< nb_tracefile
; j
++) {
2810 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
2811 LttvTracefileContext
*, j
));
2813 for(k
= 0 ; k
< hooks
->len
; k
++) {
2814 hook
= &g_array_index(hooks
, LttvTraceHook
, k
);
2815 for(l
=0;l
<hook
->fac_list
->len
;l
++) {
2816 thf
= g_array_index(hook
->fac_list
, LttvTraceHookByFacility
*, l
);
2818 lttv_hooks_remove_data(
2819 lttv_hooks_by_id_find(tfs
->parent
.event_by_id
, thf
->id
),
2825 for(k
= 0 ; k
< hooks
->len
; k
++)
2826 lttv_trace_hook_destroy(&g_array_index(hooks
, LttvTraceHook
, k
));
2827 g_array_free(hooks
, TRUE
);
2831 static gboolean
state_save_event_hook(void *hook_data
, void *call_data
)
2833 guint
*event_count
= (guint
*)hook_data
;
2835 /* Only save at LTTV_STATE_SAVE_INTERVAL */
2836 if(likely((*event_count
)++ < LTTV_STATE_SAVE_INTERVAL
))
2841 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
2843 LttvTracefileState
*tfcs
;
2845 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
2847 LttEventPosition
*ep
;
2853 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
2855 LttvAttributeValue value
;
2857 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
2858 LTTV_STATE_SAVED_STATES
);
2859 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
2860 value
= lttv_attribute_add(saved_states_tree
,
2861 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
2862 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
2863 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
2864 *(value
.v_time
) = self
->parent
.timestamp
;
2865 lttv_state_save(tcs
, saved_state_tree
);
2866 g_debug("Saving state at time %lu.%lu", self
->parent
.timestamp
.tv_sec
,
2867 self
->parent
.timestamp
.tv_nsec
);
2869 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
2874 static gboolean
state_save_after_trace_hook(void *hook_data
, void *call_data
)
2876 LttvTraceState
*tcs
= (LttvTraceState
*)(call_data
);
2878 *(tcs
->max_time_state_recomputed_in_seek
) = tcs
->parent
.time_span
.end_time
;
2883 guint
lttv_state_current_cpu(LttvTracefileState
*tfs
)
2891 static gboolean
block_start(void *hook_data
, void *call_data
)
2893 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
2895 LttvTracefileState
*tfcs
;
2897 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
2899 LttEventPosition
*ep
;
2901 guint i
, nb_block
, nb_event
, nb_tracefile
;
2905 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
2907 LttvAttributeValue value
;
2909 ep
= ltt_event_position_new();
2911 nb_tracefile
= tcs
->parent
.tracefiles
->len
;
2913 /* Count the number of events added since the last block end in any
2916 for(i
= 0 ; i
< nb_tracefile
; i
++) {
2918 LTTV_TRACEFILE_STATE(&g_array_index(tcs
->parent
.tracefiles
,
2919 LttvTracefileContext
, i
));
2920 ltt_event_position(tfcs
->parent
.e
, ep
);
2921 ltt_event_position_get(ep
, &nb_block
, &nb_event
, &tf
);
2922 tcs
->nb_event
+= nb_event
- tfcs
->saved_position
;
2923 tfcs
->saved_position
= nb_event
;
2927 if(tcs
->nb_event
>= tcs
->save_interval
) {
2928 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
2929 LTTV_STATE_SAVED_STATES
);
2930 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
2931 value
= lttv_attribute_add(saved_states_tree
,
2932 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
2933 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
2934 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
2935 *(value
.v_time
) = self
->parent
.timestamp
;
2936 lttv_state_save(tcs
, saved_state_tree
);
2938 g_debug("Saving state at time %lu.%lu", self
->parent
.timestamp
.tv_sec
,
2939 self
->parent
.timestamp
.tv_nsec
);
2941 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
2947 static gboolean
block_end(void *hook_data
, void *call_data
)
2949 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
2951 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
2955 LttEventPosition
*ep
;
2957 guint nb_block
, nb_event
;
2959 ep
= ltt_event_position_new();
2960 ltt_event_position(self
->parent
.e
, ep
);
2961 ltt_event_position_get(ep
, &nb_block
, &nb_event
, &tf
);
2962 tcs
->nb_event
+= nb_event
- self
->saved_position
+ 1;
2963 self
->saved_position
= 0;
2964 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
2971 void lttv_state_save_add_event_hooks(LttvTracesetState
*self
)
2973 LttvTraceset
*traceset
= self
->parent
.ts
;
2975 guint i
, j
, nb_trace
, nb_tracefile
;
2979 LttvTracefileState
*tfs
;
2981 LttvTraceHook hook_start
, hook_end
;
2983 nb_trace
= lttv_traceset_number(traceset
);
2984 for(i
= 0 ; i
< nb_trace
; i
++) {
2985 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
2987 lttv_trace_find_hook(ts
->parent
.t
, "core","block_start",NULL
,
2988 NULL
, NULL
, block_start
, &hook_start
);
2989 lttv_trace_find_hook(ts
->parent
.t
, "core","block_end",NULL
,
2990 NULL
, NULL
, block_end
, &hook_end
);
2992 nb_tracefile
= ts
->parent
.tracefiles
->len
;
2994 for(j
= 0 ; j
< nb_tracefile
; j
++) {
2996 LTTV_TRACEFILE_STATE(&g_array_index(ts
->parent
.tracefiles
,
2997 LttvTracefileContext
, j
));
2998 lttv_hooks_add(lttv_hooks_by_id_find(tfs
->parent
.event_by_id
,
2999 hook_start
.id
), hook_start
.h
, NULL
, LTTV_PRIO_STATE
);
3000 lttv_hooks_add(lttv_hooks_by_id_find(tfs
->parent
.event_by_id
,
3001 hook_end
.id
), hook_end
.h
, NULL
, LTTV_PRIO_STATE
);
3007 void lttv_state_save_add_event_hooks(LttvTracesetState
*self
)
3009 LttvTraceset
*traceset
= self
->parent
.ts
;
3011 guint i
, j
, nb_trace
, nb_tracefile
;
3015 LttvTracefileState
*tfs
;
3018 nb_trace
= lttv_traceset_number(traceset
);
3019 for(i
= 0 ; i
< nb_trace
; i
++) {
3021 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
3022 nb_tracefile
= ts
->parent
.tracefiles
->len
;
3024 if(ts
->has_precomputed_states
) continue;
3026 guint
*event_count
= g_new(guint
, 1);
3029 for(j
= 0 ; j
< nb_tracefile
; j
++) {
3031 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
3032 LttvTracefileContext
*, j
));
3033 lttv_hooks_add(tfs
->parent
.event
,
3034 state_save_event_hook
,
3041 lttv_process_traceset_begin(&self
->parent
,
3042 NULL
, NULL
, NULL
, NULL
, NULL
);
3046 gint
lttv_state_save_hook_add_event_hooks(void *hook_data
, void *call_data
)
3048 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
3050 lttv_state_save_add_event_hooks(tss
);
3057 void lttv_state_save_remove_event_hooks(LttvTracesetState
*self
)
3059 LttvTraceset
*traceset
= self
->parent
.ts
;
3061 guint i
, j
, nb_trace
, nb_tracefile
;
3065 LttvTracefileState
*tfs
;
3067 LttvTraceHook hook_start
, hook_end
;
3069 nb_trace
= lttv_traceset_number(traceset
);
3070 for(i
= 0 ; i
< nb_trace
; i
++) {
3071 ts
= LTTV_TRACE_STATE(self
->parent
.traces
[i
]);
3073 lttv_trace_find_hook(ts
->parent
.t
, "core","block_start",NULL
,
3074 NULL
, NULL
, block_start
, &hook_start
);
3076 lttv_trace_find_hook(ts
->parent
.t
, "core","block_end",NULL
,
3077 NULL
, NULL
, block_end
, &hook_end
);
3079 nb_tracefile
= ts
->parent
.tracefiles
->len
;
3081 for(j
= 0 ; j
< nb_tracefile
; j
++) {
3083 LTTV_TRACEFILE_STATE(&g_array_index(ts
->parent
.tracefiles
,
3084 LttvTracefileContext
, j
));
3085 lttv_hooks_remove_data(lttv_hooks_by_id_find(
3086 tfs
->parent
.event_by_id
, hook_start
.id
), hook_start
.h
, NULL
);
3087 lttv_hooks_remove_data(lttv_hooks_by_id_find(
3088 tfs
->parent
.event_by_id
, hook_end
.id
), hook_end
.h
, NULL
);
3094 void lttv_state_save_remove_event_hooks(LttvTracesetState
*self
)
3096 LttvTraceset
*traceset
= self
->parent
.ts
;
3098 guint i
, j
, nb_trace
, nb_tracefile
;
3102 LttvTracefileState
*tfs
;
3104 LttvHooks
*after_trace
= lttv_hooks_new();
3106 lttv_hooks_add(after_trace
,
3107 state_save_after_trace_hook
,
3112 lttv_process_traceset_end(&self
->parent
,
3113 NULL
, after_trace
, NULL
, NULL
, NULL
);
3115 lttv_hooks_destroy(after_trace
);
3117 nb_trace
= lttv_traceset_number(traceset
);
3118 for(i
= 0 ; i
< nb_trace
; i
++) {
3120 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
3121 nb_tracefile
= ts
->parent
.tracefiles
->len
;
3123 if(ts
->has_precomputed_states
) continue;
3125 guint
*event_count
= NULL
;
3127 for(j
= 0 ; j
< nb_tracefile
; j
++) {
3129 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
3130 LttvTracefileContext
*, j
));
3131 event_count
= lttv_hooks_remove(tfs
->parent
.event
,
3132 state_save_event_hook
);
3134 if(event_count
) g_free(event_count
);
3138 gint
lttv_state_save_hook_remove_event_hooks(void *hook_data
, void *call_data
)
3140 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
3142 lttv_state_save_remove_event_hooks(tss
);
3147 void lttv_state_traceset_seek_time_closest(LttvTracesetState
*self
, LttTime t
)
3149 LttvTraceset
*traceset
= self
->parent
.ts
;
3153 int min_pos
, mid_pos
, max_pos
;
3155 guint call_rest
= 0;
3157 LttvTraceState
*tcs
;
3159 LttvAttributeValue value
;
3161 LttvAttributeType type
;
3163 LttvAttributeName name
;
3167 LttvAttribute
*saved_states_tree
, *saved_state_tree
, *closest_tree
;
3169 //g_tree_destroy(self->parent.pqueue);
3170 //self->parent.pqueue = g_tree_new(compare_tracefile);
3172 g_info("Entering seek_time_closest for time %lu.%lu", t
.tv_sec
, t
.tv_nsec
);
3174 nb_trace
= lttv_traceset_number(traceset
);
3175 for(i
= 0 ; i
< nb_trace
; i
++) {
3176 tcs
= (LttvTraceState
*)self
->parent
.traces
[i
];
3178 if(ltt_time_compare(t
, *(tcs
->max_time_state_recomputed_in_seek
)) < 0) {
3179 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
3180 LTTV_STATE_SAVED_STATES
);
3183 if(saved_states_tree
) {
3184 max_pos
= lttv_attribute_get_number(saved_states_tree
) - 1;
3185 mid_pos
= max_pos
/ 2;
3186 while(min_pos
< max_pos
) {
3187 type
= lttv_attribute_get(saved_states_tree
, mid_pos
, &name
, &value
,
3189 g_assert(type
== LTTV_GOBJECT
);
3190 saved_state_tree
= *((LttvAttribute
**)(value
.v_gobject
));
3191 type
= lttv_attribute_get_by_name(saved_state_tree
, LTTV_STATE_TIME
,
3193 g_assert(type
== LTTV_TIME
);
3194 if(ltt_time_compare(*(value
.v_time
), t
) < 0) {
3196 closest_tree
= saved_state_tree
;
3198 else max_pos
= mid_pos
- 1;
3200 mid_pos
= (min_pos
+ max_pos
+ 1) / 2;
3204 /* restore the closest earlier saved state */
3206 lttv_state_restore(tcs
, closest_tree
);
3210 /* There is no saved state, yet we want to have it. Restart at T0 */
3212 restore_init_state(tcs
);
3213 lttv_process_trace_seek_time(&(tcs
->parent
), ltt_time_zero
);
3216 /* We want to seek quickly without restoring/updating the state */
3218 restore_init_state(tcs
);
3219 lttv_process_trace_seek_time(&(tcs
->parent
), t
);
3222 if(!call_rest
) g_info("NOT Calling restore");
3227 traceset_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
3233 traceset_state_finalize (LttvTracesetState
*self
)
3235 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
3236 finalize(G_OBJECT(self
));
3241 traceset_state_class_init (LttvTracesetContextClass
*klass
)
3243 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
3245 gobject_class
->finalize
= (void (*)(GObject
*self
)) traceset_state_finalize
;
3246 klass
->init
= (void (*)(LttvTracesetContext
*self
, LttvTraceset
*ts
))init
;
3247 klass
->fini
= (void (*)(LttvTracesetContext
*self
))fini
;
3248 klass
->new_traceset_context
= new_traceset_context
;
3249 klass
->new_trace_context
= new_trace_context
;
3250 klass
->new_tracefile_context
= new_tracefile_context
;
3255 lttv_traceset_state_get_type(void)
3257 static GType type
= 0;
3259 static const GTypeInfo info
= {
3260 sizeof (LttvTracesetStateClass
),
3261 NULL
, /* base_init */
3262 NULL
, /* base_finalize */
3263 (GClassInitFunc
) traceset_state_class_init
, /* class_init */
3264 NULL
, /* class_finalize */
3265 NULL
, /* class_data */
3266 sizeof (LttvTracesetState
),
3267 0, /* n_preallocs */
3268 (GInstanceInitFunc
) traceset_state_instance_init
, /* instance_init */
3269 NULL
/* value handling */
3272 type
= g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE
, "LttvTracesetStateType",
3280 trace_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
3286 trace_state_finalize (LttvTraceState
*self
)
3288 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_CONTEXT_TYPE
))->
3289 finalize(G_OBJECT(self
));
3294 trace_state_class_init (LttvTraceStateClass
*klass
)
3296 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
3298 gobject_class
->finalize
= (void (*)(GObject
*self
)) trace_state_finalize
;
3299 klass
->state_save
= state_save
;
3300 klass
->state_restore
= state_restore
;
3301 klass
->state_saved_free
= state_saved_free
;
3306 lttv_trace_state_get_type(void)
3308 static GType type
= 0;
3310 static const GTypeInfo info
= {
3311 sizeof (LttvTraceStateClass
),
3312 NULL
, /* base_init */
3313 NULL
, /* base_finalize */
3314 (GClassInitFunc
) trace_state_class_init
, /* class_init */
3315 NULL
, /* class_finalize */
3316 NULL
, /* class_data */
3317 sizeof (LttvTraceState
),
3318 0, /* n_preallocs */
3319 (GInstanceInitFunc
) trace_state_instance_init
, /* instance_init */
3320 NULL
/* value handling */
3323 type
= g_type_register_static (LTTV_TRACE_CONTEXT_TYPE
,
3324 "LttvTraceStateType", &info
, 0);
3331 tracefile_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
3337 tracefile_state_finalize (LttvTracefileState
*self
)
3339 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_CONTEXT_TYPE
))->
3340 finalize(G_OBJECT(self
));
3345 tracefile_state_class_init (LttvTracefileStateClass
*klass
)
3347 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
3349 gobject_class
->finalize
= (void (*)(GObject
*self
)) tracefile_state_finalize
;
3354 lttv_tracefile_state_get_type(void)
3356 static GType type
= 0;
3358 static const GTypeInfo info
= {
3359 sizeof (LttvTracefileStateClass
),
3360 NULL
, /* base_init */
3361 NULL
, /* base_finalize */
3362 (GClassInitFunc
) tracefile_state_class_init
, /* class_init */
3363 NULL
, /* class_finalize */
3364 NULL
, /* class_data */
3365 sizeof (LttvTracefileState
),
3366 0, /* n_preallocs */
3367 (GInstanceInitFunc
) tracefile_state_instance_init
, /* instance_init */
3368 NULL
/* value handling */
3371 type
= g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE
,
3372 "LttvTracefileStateType", &info
, 0);
3378 static void module_init()
3380 LTTV_STATE_UNNAMED
= g_quark_from_string("UNNAMED");
3381 LTTV_STATE_UNBRANDED
= g_quark_from_string("UNBRANDED");
3382 LTTV_STATE_MODE_UNKNOWN
= g_quark_from_string("MODE_UNKNOWN");
3383 LTTV_STATE_USER_MODE
= g_quark_from_string("USER_MODE");
3384 LTTV_STATE_SYSCALL
= g_quark_from_string("SYSCALL");
3385 LTTV_STATE_TRAP
= g_quark_from_string("TRAP");
3386 LTTV_STATE_IRQ
= g_quark_from_string("IRQ");
3387 LTTV_STATE_SOFT_IRQ
= g_quark_from_string("SOFTIRQ");
3388 LTTV_STATE_SUBMODE_UNKNOWN
= g_quark_from_string("UNKNOWN");
3389 LTTV_STATE_SUBMODE_NONE
= g_quark_from_string("NONE");
3390 LTTV_STATE_WAIT_FORK
= g_quark_from_string("WAIT_FORK");
3391 LTTV_STATE_WAIT_CPU
= g_quark_from_string("WAIT_CPU");
3392 LTTV_STATE_EXIT
= g_quark_from_string("EXIT");
3393 LTTV_STATE_ZOMBIE
= g_quark_from_string("ZOMBIE");
3394 LTTV_STATE_WAIT
= g_quark_from_string("WAIT");
3395 LTTV_STATE_RUN
= g_quark_from_string("RUN");
3396 LTTV_STATE_DEAD
= g_quark_from_string("DEAD");
3397 LTTV_STATE_USER_THREAD
= g_quark_from_string("USER_THREAD");
3398 LTTV_STATE_KERNEL_THREAD
= g_quark_from_string("KERNEL_THREAD");
3399 LTTV_STATE_TRACEFILES
= g_quark_from_string("tracefiles");
3400 LTTV_STATE_PROCESSES
= g_quark_from_string("processes");
3401 LTTV_STATE_PROCESS
= g_quark_from_string("process");
3402 LTTV_STATE_RUNNING_PROCESS
= g_quark_from_string("running_process");
3403 LTTV_STATE_EVENT
= g_quark_from_string("event");
3404 LTTV_STATE_SAVED_STATES
= g_quark_from_string("saved states");
3405 LTTV_STATE_SAVED_STATES_TIME
= g_quark_from_string("saved states time");
3406 LTTV_STATE_TIME
= g_quark_from_string("time");
3407 LTTV_STATE_HOOKS
= g_quark_from_string("saved state hooks");
3408 LTTV_STATE_NAME_TABLES
= g_quark_from_string("name tables");
3409 LTTV_STATE_TRACE_STATE_USE_COUNT
=
3410 g_quark_from_string("trace_state_use_count");
3413 LTT_FACILITY_KERNEL
= g_quark_from_string("kernel");
3414 LTT_FACILITY_KERNEL_ARCH
= g_quark_from_string("kernel_arch");
3415 LTT_FACILITY_PROCESS
= g_quark_from_string("process");
3416 LTT_FACILITY_FS
= g_quark_from_string("fs");
3417 LTT_FACILITY_STATEDUMP
= g_quark_from_string("statedump");
3418 LTT_FACILITY_USER_GENERIC
= g_quark_from_string("user_generic");
3421 LTT_EVENT_SYSCALL_ENTRY
= g_quark_from_string("syscall_entry");
3422 LTT_EVENT_SYSCALL_EXIT
= g_quark_from_string("syscall_exit");
3423 LTT_EVENT_TRAP_ENTRY
= g_quark_from_string("trap_entry");
3424 LTT_EVENT_TRAP_EXIT
= g_quark_from_string("trap_exit");
3425 LTT_EVENT_IRQ_ENTRY
= g_quark_from_string("irq_entry");
3426 LTT_EVENT_IRQ_EXIT
= g_quark_from_string("irq_exit");
3427 LTT_EVENT_SOFT_IRQ_ENTRY
= g_quark_from_string("soft_irq_entry");
3428 LTT_EVENT_SOFT_IRQ_EXIT
= g_quark_from_string("soft_irq_exit");
3429 LTT_EVENT_SCHEDCHANGE
= g_quark_from_string("schedchange");
3430 LTT_EVENT_FORK
= g_quark_from_string("fork");
3431 LTT_EVENT_KERNEL_THREAD
= g_quark_from_string("kernel_thread");
3432 LTT_EVENT_EXIT
= g_quark_from_string("exit");
3433 LTT_EVENT_FREE
= g_quark_from_string("free");
3434 LTT_EVENT_EXEC
= g_quark_from_string("exec");
3435 LTT_EVENT_ENUM_PROCESS_STATE
= g_quark_from_string("enumerate_process_state");
3436 LTT_EVENT_STATEDUMP_END
= g_quark_from_string("statedump_end");
3437 LTT_EVENT_FUNCTION_ENTRY
= g_quark_from_string("function_entry");
3438 LTT_EVENT_FUNCTION_EXIT
= g_quark_from_string("function_exit");
3439 LTT_EVENT_THREAD_BRAND
= g_quark_from_string("thread_brand");
3442 LTT_FIELD_SYSCALL_ID
= g_quark_from_string("syscall_id");
3443 LTT_FIELD_TRAP_ID
= g_quark_from_string("trap_id");
3444 LTT_FIELD_IRQ_ID
= g_quark_from_string("irq_id");
3445 LTT_FIELD_SOFT_IRQ_ID
= g_quark_from_string("softirq_id");
3446 LTT_FIELD_OUT
= g_quark_from_string("out");
3447 LTT_FIELD_IN
= g_quark_from_string("in");
3448 LTT_FIELD_OUT_STATE
= g_quark_from_string("out_state");
3449 LTT_FIELD_PARENT_PID
= g_quark_from_string("parent_pid");
3450 LTT_FIELD_CHILD_PID
= g_quark_from_string("child_pid");
3451 LTT_FIELD_PID
= g_quark_from_string("pid");
3452 LTT_FIELD_TGID
= g_quark_from_string("tgid");
3453 LTT_FIELD_FILENAME
= g_quark_from_string("filename");
3454 LTT_FIELD_NAME
= g_quark_from_string("name");
3455 LTT_FIELD_TYPE
= g_quark_from_string("type");
3456 LTT_FIELD_MODE
= g_quark_from_string("mode");
3457 LTT_FIELD_SUBMODE
= g_quark_from_string("submode");
3458 LTT_FIELD_STATUS
= g_quark_from_string("status");
3459 LTT_FIELD_THIS_FN
= g_quark_from_string("this_fn");
3460 LTT_FIELD_CALL_SITE
= g_quark_from_string("call_site");
3464 static void module_destroy()
3469 LTTV_MODULE("state", "State computation", \
3470 "Update the system state, possibly saving it at intervals", \
3471 module_init
, module_destroy
)