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,
25 #include <lttv/lttv.h>
26 #include <lttv/module.h>
27 #include <lttv/state.h>
28 #include <ltt/trace.h>
29 #include <ltt/event.h>
31 #include <ltt/marker-desc.h>
34 #include <ltt/ltt-private.h>
39 * usertrace is there only to be able to update the current CPU of the
40 * usertraces when there is a schedchange. it is a way to link the ProcessState
41 * to the associated usertrace. Link only created upon thread creation.
43 * The cpu id is necessary : it gives us back the current ProcessState when we
44 * are considering data from the usertrace.
47 #define PREALLOCATED_EXECUTION_STACK 10
53 LTT_CHANNEL_GLOBAL_STATE
,
54 LTT_CHANNEL_IRQ_STATE
,
55 LTT_CHANNEL_MODULE_STATE
,
56 LTT_CHANNEL_NETIF_STATE
,
57 LTT_CHANNEL_SOFTIRQ_STATE
,
58 LTT_CHANNEL_SWAP_STATE
,
59 LTT_CHANNEL_SYSCALL_STATE
,
60 LTT_CHANNEL_TASK_STATE
,
62 LTT_CHANNEL_KPROBE_STATE
,
66 LTT_CHANNEL_USERSPACE
,
72 LTT_EVENT_SYSCALL_ENTRY
,
73 LTT_EVENT_SYSCALL_EXIT
,
74 LTT_EVENT_PAGE_FAULT_NOSEM_ENTRY
,
75 LTT_EVENT_PAGE_FAULT_NOSEM_EXIT
,
76 LTT_EVENT_PAGE_FAULT_ENTRY
,
77 LTT_EVENT_PAGE_FAULT_EXIT
,
82 LTT_EVENT_SOFT_IRQ_RAISE
,
83 LTT_EVENT_SOFT_IRQ_ENTRY
,
84 LTT_EVENT_SOFT_IRQ_EXIT
,
85 LTT_EVENT_SCHED_SCHEDULE
,
86 LTT_EVENT_SCHED_TRY_WAKEUP
,
87 LTT_EVENT_PROCESS_FORK
,
88 LTT_EVENT_KTHREAD_CREATE
,
89 LTT_EVENT_PROCESS_EXIT
,
90 LTT_EVENT_PROCESS_FREE
,
92 LTT_EVENT_PROCESS_STATE
,
93 LTT_EVENT_STATEDUMP_END
,
94 LTT_EVENT_FUNCTION_ENTRY
,
95 LTT_EVENT_FUNCTION_EXIT
,
96 LTT_EVENT_THREAD_BRAND
,
97 LTT_EVENT_REQUEST_ISSUE
,
98 LTT_EVENT_REQUEST_COMPLETE
,
99 LTT_EVENT_LIST_INTERRUPT
,
100 LTT_EVENT_SYS_CALL_TABLE
,
101 LTT_EVENT_SOFTIRQ_VEC
,
102 LTT_EVENT_KPROBE_TABLE
,
106 LTT_EVENT_POLL_EVENT
;
111 LTT_FIELD_SYSCALL_ID
,
114 LTT_FIELD_SOFT_IRQ_ID
,
117 LTT_FIELD_PREV_STATE
,
118 LTT_FIELD_PARENT_PID
,
122 LTT_FIELD_CHILD_TGID
,
144 LTTV_STATE_MODE_UNKNOWN
,
145 LTTV_STATE_USER_MODE
,
152 LTTV_STATE_SUBMODE_UNKNOWN
,
153 LTTV_STATE_SUBMODE_NONE
;
157 LTTV_STATE_WAIT_FORK
,
166 LTTV_STATE_UNBRANDED
;
169 LTTV_STATE_USER_THREAD
,
170 LTTV_STATE_KERNEL_THREAD
;
188 LTTV_BDEV_BUSY_READING
,
189 LTTV_BDEV_BUSY_WRITING
;
192 LTTV_STATE_TRACEFILES
,
193 LTTV_STATE_PROCESSES
,
195 LTTV_STATE_RUNNING_PROCESS
,
197 LTTV_STATE_SAVED_STATES
,
198 LTTV_STATE_SAVED_STATES_TIME
,
201 LTTV_STATE_NAME_TABLES
,
202 LTTV_STATE_TRACE_STATE_USE_COUNT
,
203 LTTV_STATE_RESOURCE_CPUS
,
204 LTTV_STATE_RESOURCE_CPUS_COUNT
,
205 LTTV_STATE_RESOURCE_IRQS
,
206 LTTV_STATE_RESOURCE_SOFT_IRQS
,
207 LTTV_STATE_RESOURCE_TRAPS
,
208 LTTV_STATE_RESOURCE_BLKDEVS
;
210 static void create_max_time(LttvTraceState
*tcs
);
212 static void get_max_time(LttvTraceState
*tcs
);
214 static void free_max_time(LttvTraceState
*tcs
);
216 static void create_name_tables(LttvTraceState
*tcs
);
218 static void get_name_tables(LttvTraceState
*tcs
);
220 static void free_name_tables(LttvTraceState
*tcs
);
222 static void free_saved_state(LttvTraceState
*tcs
);
224 static void lttv_state_free_process_table(GHashTable
*processes
);
226 static void lttv_trace_states_read_raw(LttvTraceState
*tcs
, FILE *fp
,
227 GPtrArray
*quarktable
);
229 /* Resource function prototypes */
230 static LttvBdevState
*get_hashed_bdevstate(LttvTraceState
*ts
, guint32 devcode
);
231 static LttvBdevState
*bdevstate_new(void);
232 static void bdevstate_free(LttvBdevState
*);
233 static void bdevstate_free_cb(gpointer key
, gpointer value
, gpointer user_data
);
234 static LttvBdevState
*bdevstate_copy(LttvBdevState
*bds
);
237 #if (__WORDSIZE == 32)
238 guint
guint64_hash(gconstpointer key
)
240 guint64 ukey
= *(const guint64
*)key
;
242 return (guint
)ukey
^ (guint
)(ukey
>> 32);
245 gboolean
guint64_equal(gconstpointer a
, gconstpointer b
)
247 guint64 ua
= *(const guint64
*)a
;
248 guint64 ub
= *(const guint64
*)b
;
254 void lttv_state_save(LttvTraceState
*self
, LttvAttribute
*container
)
256 LTTV_TRACE_STATE_GET_CLASS(self
)->state_save(self
, container
);
260 void lttv_state_restore(LttvTraceState
*self
, LttvAttribute
*container
)
262 LTTV_TRACE_STATE_GET_CLASS(self
)->state_restore(self
, container
);
266 void lttv_state_state_saved_free(LttvTraceState
*self
,
267 LttvAttribute
*container
)
269 LTTV_TRACE_STATE_GET_CLASS(self
)->state_saved_free(self
, container
);
273 guint
process_hash(gconstpointer key
)
275 guint pid
= ((const LttvProcessState
*)key
)->pid
;
276 return (pid
>>8 ^ pid
>>4 ^ pid
>>2 ^ pid
) ;
280 /* If the hash table hash function is well distributed,
281 * the process_equal should compare different pid */
282 gboolean
process_equal(gconstpointer a
, gconstpointer b
)
284 const LttvProcessState
*process_a
, *process_b
;
287 process_a
= (const LttvProcessState
*)a
;
288 process_b
= (const LttvProcessState
*)b
;
290 if(likely(process_a
->pid
!= process_b
->pid
)) ret
= FALSE
;
291 else if(likely(process_a
->pid
== 0 &&
292 process_a
->cpu
!= process_b
->cpu
)) ret
= FALSE
;
297 static void delete_usertrace(gpointer key
, gpointer value
, gpointer user_data
)
299 g_tree_destroy((GTree
*)value
);
302 static void lttv_state_free_usertraces(GHashTable
*usertraces
)
304 g_hash_table_foreach(usertraces
, delete_usertrace
, NULL
);
305 g_hash_table_destroy(usertraces
);
308 gboolean
rettrue(gpointer key
, gpointer value
, gpointer user_data
)
313 static guint
check_expand(nb
, id
)
318 return max(id
+ 1, nb
* 2);
321 static void expand_name_table(LttvTraceState
*ts
, GQuark
**table
,
322 guint nb
, guint new_nb
)
324 /* Expand an incomplete table */
325 GQuark
*old_table
= *table
;
326 *table
= g_new(GQuark
, new_nb
);
327 memcpy(*table
, old_table
, nb
* sizeof(GQuark
));
331 static void fill_name_table(LttvTraceState
*ts
, GQuark
*table
, guint nb
,
332 guint new_nb
, const char *def_string
)
335 GString
*fe_name
= g_string_new("");
336 for(i
= nb
; i
< new_nb
; i
++) {
337 g_string_printf(fe_name
, "%s %d", def_string
, i
);
338 table
[i
] = g_quark_from_string(fe_name
->str
);
340 g_string_free(fe_name
, TRUE
);
343 static void expand_syscall_table(LttvTraceState
*ts
, int id
)
345 LttvNameTables
*nt
= ts
->name_tables
;
348 new_nb
= check_expand(nt
->nb_syscalls
, id
);
349 if(likely(new_nb
== nt
->nb_syscalls
))
351 expand_name_table(ts
, &nt
->syscall_names
, nt
->nb_syscalls
, new_nb
);
352 fill_name_table(ts
, nt
->syscall_names
, nt
->nb_syscalls
, new_nb
, "syscall");
353 /* Update the table size */
354 nt
->nb_syscalls
= new_nb
;
357 static void expand_kprobe_table(LttvTraceState
*ts
, guint64 ip
, char *symbol
)
359 LttvNameTables
*nt
= ts
->name_tables
;
360 #if (__WORDSIZE == 32)
361 guint64
*ip_ptr
= g_new(guint64
, 1);
362 g_hash_table_insert(nt
->kprobe_hash
, ip_ptr
,
363 (gpointer
)(glong
)g_quark_from_string(symbol
));
365 g_hash_table_insert(nt
->kprobe_hash
, (gpointer
)ip
,
366 (gpointer
)(glong
)g_quark_from_string(symbol
));
370 static void expand_trap_table(LttvTraceState
*ts
, int id
)
372 LttvNameTables
*nt
= ts
->name_tables
;
373 LttvTrapState
*old_table
;
376 new_nb
= check_expand(nt
->nb_traps
, id
);
377 if(likely(new_nb
== nt
->nb_traps
))
380 expand_name_table(ts
, &nt
->trap_names
, nt
->nb_traps
, new_nb
);
381 fill_name_table(ts
, nt
->trap_names
, nt
->nb_traps
, new_nb
, "trap");
383 old_table
= ts
->trap_states
;
384 ts
->trap_states
= g_new(LttvTrapState
, new_nb
);
385 memcpy(ts
->trap_states
, old_table
, nt
->nb_traps
* sizeof(LttvTrapState
));
387 for(i
= nt
->nb_traps
; i
< new_nb
; i
++)
388 ts
->trap_states
[i
].running
= 0;
390 /* Update the table size */
391 nt
->nb_traps
= new_nb
;
394 static void expand_irq_table(LttvTraceState
*ts
, int id
)
396 LttvNameTables
*nt
= ts
->name_tables
;
397 LttvIRQState
*old_table
;
400 new_nb
= check_expand(nt
->nb_irqs
, id
);
401 if(likely(new_nb
== nt
->nb_irqs
))
404 expand_name_table(ts
, &nt
->irq_names
, nt
->nb_irqs
, new_nb
);
405 fill_name_table(ts
, nt
->irq_names
, nt
->nb_irqs
, new_nb
, "irq");
407 old_table
= ts
->irq_states
;
408 ts
->irq_states
= g_new(LttvIRQState
, new_nb
);
409 memcpy(ts
->irq_states
, old_table
, nt
->nb_irqs
* sizeof(LttvIRQState
));
411 for(i
= nt
->nb_irqs
; i
< new_nb
; i
++)
412 ts
->irq_states
[i
].mode_stack
=
413 g_array_new(FALSE
, FALSE
, sizeof(LttvIRQMode
));
415 /* Update the table size */
416 nt
->nb_irqs
= new_nb
;
419 static void expand_soft_irq_table(LttvTraceState
*ts
, int id
)
421 LttvNameTables
*nt
= ts
->name_tables
;
422 LttvSoftIRQState
*old_table
;
425 new_nb
= check_expand(nt
->nb_soft_irqs
, id
);
426 if(likely(new_nb
== nt
->nb_soft_irqs
))
429 expand_name_table(ts
, &nt
->soft_irq_names
, nt
->nb_soft_irqs
, new_nb
);
430 fill_name_table(ts
, nt
->soft_irq_names
, nt
->nb_soft_irqs
, new_nb
, "softirq");
432 old_table
= ts
->soft_irq_states
;
433 ts
->soft_irq_states
= g_new(LttvSoftIRQState
, new_nb
);
434 memcpy(ts
->soft_irq_states
, old_table
,
435 nt
->nb_soft_irqs
* sizeof(LttvSoftIRQState
));
437 for(i
= nt
->nb_soft_irqs
; i
< new_nb
; i
++)
438 ts
->soft_irq_states
[i
].running
= 0;
440 /* Update the table size */
441 nt
->nb_soft_irqs
= new_nb
;
444 static void restore_init_state(LttvTraceState
*self
)
446 guint i
, nb_cpus
, nb_irqs
, nb_soft_irqs
, nb_traps
;
448 //LttvTracefileState *tfcs;
450 LttTime start_time
, end_time
;
452 /* Free the process tables */
453 if(self
->processes
!= NULL
) lttv_state_free_process_table(self
->processes
);
454 if(self
->usertraces
!= NULL
) lttv_state_free_usertraces(self
->usertraces
);
455 self
->processes
= g_hash_table_new(process_hash
, process_equal
);
456 self
->usertraces
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
459 /* Seek time to beginning */
460 // Mathieu : fix : don't seek traceset here : causes inconsistency in seek
461 // closest. It's the tracecontext job to seek the trace to the beginning
462 // anyway : the init state might be used at the middle of the trace as well...
463 //g_tree_destroy(self->parent.ts_context->pqueue);
464 //self->parent.ts_context->pqueue = g_tree_new(compare_tracefile);
466 ltt_trace_time_span_get(self
->parent
.t
, &start_time
, &end_time
);
468 //lttv_process_trace_seek_time(&self->parent, ltt_time_zero);
470 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
471 nb_irqs
= self
->name_tables
->nb_irqs
;
472 nb_soft_irqs
= self
->name_tables
->nb_soft_irqs
;
473 nb_traps
= self
->name_tables
->nb_traps
;
475 /* Put the per cpu running_process to beginning state : process 0. */
476 for(i
=0; i
< nb_cpus
; i
++) {
477 LttvExecutionState
*es
;
478 self
->running_process
[i
] = lttv_state_create_process(self
, NULL
, i
, 0, 0,
479 LTTV_STATE_UNNAMED
, &start_time
);
480 /* We are not sure is it's a kernel thread or normal thread, put the
481 * bottom stack state to unknown */
482 self
->running_process
[i
]->execution_stack
=
483 g_array_set_size(self
->running_process
[i
]->execution_stack
, 1);
484 es
= self
->running_process
[i
]->state
=
485 &g_array_index(self
->running_process
[i
]->execution_stack
,
486 LttvExecutionState
, 0);
487 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
488 es
->s
= LTTV_STATE_UNNAMED
;
490 //self->running_process[i]->state->s = LTTV_STATE_RUN;
491 self
->running_process
[i
]->cpu
= i
;
493 /* reset cpu states */
494 if(self
->cpu_states
[i
].mode_stack
->len
> 0) {
495 g_array_remove_range(self
->cpu_states
[i
].mode_stack
, 0,
496 self
->cpu_states
[i
].mode_stack
->len
);
497 if(self
->cpu_states
[i
].irq_stack
->len
)
498 g_array_remove_range(self
->cpu_states
[i
].irq_stack
, 0,
499 self
->cpu_states
[i
].irq_stack
->len
);
500 if(self
->cpu_states
[i
].softirq_stack
->len
)
501 g_array_remove_range(self
->cpu_states
[i
].softirq_stack
, 0,
502 self
->cpu_states
[i
].softirq_stack
->len
);
503 if(self
->cpu_states
[i
].trap_stack
->len
)
504 g_array_remove_range(self
->cpu_states
[i
].trap_stack
, 0,
505 self
->cpu_states
[i
].trap_stack
->len
);
509 /* reset irq states */
510 for(i
=0; i
<nb_irqs
; i
++) {
511 if(self
->irq_states
[i
].mode_stack
->len
> 0)
512 g_array_remove_range(self
->irq_states
[i
].mode_stack
, 0,
513 self
->irq_states
[i
].mode_stack
->len
);
516 /* reset softirq states */
517 for(i
=0; i
<nb_soft_irqs
; i
++) {
518 self
->soft_irq_states
[i
].pending
= 0;
519 self
->soft_irq_states
[i
].running
= 0;
522 /* reset trap states */
523 for(i
=0; i
<nb_traps
; i
++) {
524 self
->trap_states
[i
].running
= 0;
527 /* reset bdev states */
528 g_hash_table_foreach(self
->bdev_states
, bdevstate_free_cb
, NULL
);
529 //g_hash_table_steal_all(self->bdev_states);
530 g_hash_table_foreach_steal(self
->bdev_states
, rettrue
, NULL
);
533 nb_tracefile
= self
->parent
.tracefiles
->len
;
535 for(i
= 0 ; i
< nb_tracefile
; i
++) {
537 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
538 LttvTracefileContext
*, i
));
539 ltt_trace_time_span_get(self
->parent
.t
, &tfcs
->parent
.timestamp
, NULL
);
540 // tfcs->saved_position = 0;
541 tfcs
->process
= lttv_state_create_process(tfcs
, NULL
,0);
542 tfcs
->process
->state
->s
= LTTV_STATE_RUN
;
543 tfcs
->process
->last_cpu
= tfcs
->cpu_name
;
544 tfcs
->process
->last_cpu_index
= ltt_tracefile_num(((LttvTracefileContext
*)tfcs
)->tf
);
549 //static LttTime time_zero = {0,0};
551 static gint
compare_usertraces(gconstpointer a
, gconstpointer b
,
554 const LttTime
*t1
= (const LttTime
*)a
;
555 const LttTime
*t2
= (const LttTime
*)b
;
557 return ltt_time_compare(*t1
, *t2
);
560 static void free_usertrace_key(gpointer data
)
565 #define MAX_STRING_LEN 4096
567 static void state_load_saved_states(LttvTraceState
*tcs
)
570 GPtrArray
*quarktable
;
571 const char *trace_path
;
575 tcs
->has_precomputed_states
= FALSE
;
579 gchar buf
[MAX_STRING_LEN
];
582 trace_path
= g_quark_to_string(ltt_trace_name(tcs
->parent
.t
));
583 strncpy(path
, trace_path
, PATH_MAX
-1);
584 count
= strnlen(trace_path
, PATH_MAX
-1);
585 // quarktable : open, test
586 strncat(path
, "/precomputed/quarktable", PATH_MAX
-count
-1);
587 fp
= fopen(path
, "r");
589 quarktable
= g_ptr_array_sized_new(4096);
591 /* Index 0 is null */
593 if(hdr
== EOF
) return;
594 g_assert(hdr
== HDR_QUARKS
);
598 if(hdr
== EOF
) break;
599 g_assert(hdr
== HDR_QUARK
);
600 g_ptr_array_set_size(quarktable
, q
+1);
603 fread(&buf
[i
], sizeof(gchar
), 1, fp
);
604 if(buf
[i
] == '\0' || feof(fp
)) break;
607 len
= strnlen(buf
, MAX_STRING_LEN
-1);
608 g_ptr_array_index (quarktable
, q
) = g_new(gchar
, len
+1);
609 strncpy(g_ptr_array_index (quarktable
, q
), buf
, len
+1);
615 // saved_states : open, test
616 strncpy(path
, trace_path
, PATH_MAX
-1);
617 count
= strnlen(trace_path
, PATH_MAX
-1);
618 strncat(path
, "/precomputed/states", PATH_MAX
-count
-1);
619 fp
= fopen(path
, "r");
623 if(hdr
!= HDR_TRACE
) goto end
;
625 lttv_trace_states_read_raw(tcs
, fp
, quarktable
);
627 tcs
->has_precomputed_states
= TRUE
;
632 /* Free the quarktable */
633 for(i
=0; i
<quarktable
->len
; i
++) {
634 string
= g_ptr_array_index (quarktable
, i
);
637 g_ptr_array_free(quarktable
, TRUE
);
641 static void init(LttvTracesetState
*self
, LttvTraceset
*ts
)
643 guint i
, j
, nb_trace
, nb_tracefile
, nb_cpu
;
646 LttvTraceContext
*tc
;
650 LttvTracefileState
*tfcs
;
652 LttvAttributeValue v
;
654 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
655 init((LttvTracesetContext
*)self
, ts
);
657 nb_trace
= lttv_traceset_number(ts
);
658 for(i
= 0 ; i
< nb_trace
; i
++) {
659 tc
= self
->parent
.traces
[i
];
660 tcs
= LTTV_TRACE_STATE(tc
);
661 tcs
->save_interval
= LTTV_STATE_SAVE_INTERVAL
;
662 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_TRACE_STATE_USE_COUNT
,
666 if(*(v
.v_uint
) == 1) {
667 create_name_tables(tcs
);
668 create_max_time(tcs
);
670 get_name_tables(tcs
);
673 nb_tracefile
= tc
->tracefiles
->len
;
674 nb_cpu
= ltt_trace_get_num_cpu(tc
->t
);
675 nb_irq
= tcs
->name_tables
->nb_irqs
;
676 tcs
->processes
= NULL
;
677 tcs
->usertraces
= NULL
;
678 tcs
->running_process
= g_new(LttvProcessState
*, nb_cpu
);
680 /* init cpu resource stuff */
681 tcs
->cpu_states
= g_new(LttvCPUState
, nb_cpu
);
682 for(j
= 0; j
<nb_cpu
; j
++) {
683 tcs
->cpu_states
[j
].mode_stack
= g_array_new(FALSE
, FALSE
, sizeof(LttvCPUMode
));
684 tcs
->cpu_states
[j
].irq_stack
= g_array_new(FALSE
, FALSE
, sizeof(gint
));
685 tcs
->cpu_states
[j
].softirq_stack
= g_array_new(FALSE
, FALSE
, sizeof(gint
));
686 tcs
->cpu_states
[j
].trap_stack
= g_array_new(FALSE
, FALSE
, sizeof(gint
));
687 g_assert(tcs
->cpu_states
[j
].mode_stack
!= NULL
);
690 /* init irq resource stuff */
691 tcs
->irq_states
= g_new(LttvIRQState
, nb_irq
);
692 for(j
= 0; j
<nb_irq
; j
++) {
693 tcs
->irq_states
[j
].mode_stack
= g_array_new(FALSE
, FALSE
, sizeof(LttvIRQMode
));
694 g_assert(tcs
->irq_states
[j
].mode_stack
!= NULL
);
697 /* init soft irq stuff */
698 /* the kernel has a statically fixed max of 32 softirqs */
699 tcs
->soft_irq_states
= g_new(LttvSoftIRQState
, tcs
->name_tables
->nb_soft_irqs
);
701 /* init trap stuff */
702 tcs
->trap_states
= g_new(LttvTrapState
, tcs
->name_tables
->nb_traps
);
704 /* init bdev resource stuff */
705 tcs
->bdev_states
= g_hash_table_new(g_int_hash
, g_int_equal
);
707 restore_init_state(tcs
);
708 for(j
= 0 ; j
< nb_tracefile
; j
++) {
710 LTTV_TRACEFILE_STATE(g_array_index(tc
->tracefiles
,
711 LttvTracefileContext
*, j
));
712 tfcs
->tracefile_name
= ltt_tracefile_name(tfcs
->parent
.tf
);
713 tfcs
->cpu
= ltt_tracefile_cpu(tfcs
->parent
.tf
);
714 tfcs
->cpu_state
= &(tcs
->cpu_states
[tfcs
->cpu
]);
715 if(ltt_tracefile_tid(tfcs
->parent
.tf
) != 0) {
716 /* It's a Usertrace */
717 guint tid
= ltt_tracefile_tid(tfcs
->parent
.tf
);
718 GTree
*usertrace_tree
= (GTree
*)g_hash_table_lookup(tcs
->usertraces
,
719 GUINT_TO_POINTER(tid
));
720 if(!usertrace_tree
) {
721 usertrace_tree
= g_tree_new_full(compare_usertraces
,
722 NULL
, free_usertrace_key
, NULL
);
723 g_hash_table_insert(tcs
->usertraces
,
724 GUINT_TO_POINTER(tid
), usertrace_tree
);
726 LttTime
*timestamp
= g_new(LttTime
, 1);
727 *timestamp
= ltt_interpolate_time_from_tsc(tfcs
->parent
.tf
,
728 ltt_tracefile_creation(tfcs
->parent
.tf
));
729 g_tree_insert(usertrace_tree
, timestamp
, tfcs
);
733 /* See if the trace has saved states */
734 state_load_saved_states(tcs
);
738 static void fini(LttvTracesetState
*self
)
744 //LttvTracefileState *tfcs;
746 LttvAttributeValue v
;
748 nb_trace
= lttv_traceset_number(LTTV_TRACESET_CONTEXT(self
)->ts
);
749 for(i
= 0 ; i
< nb_trace
; i
++) {
750 tcs
= (LttvTraceState
*)(LTTV_TRACESET_CONTEXT(self
)->traces
[i
]);
751 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_TRACE_STATE_USE_COUNT
,
754 g_assert(*(v
.v_uint
) != 0);
757 if(*(v
.v_uint
) == 0) {
758 free_name_tables(tcs
);
760 free_saved_state(tcs
);
762 g_free(tcs
->running_process
);
763 tcs
->running_process
= NULL
;
764 lttv_state_free_process_table(tcs
->processes
);
765 lttv_state_free_usertraces(tcs
->usertraces
);
766 tcs
->processes
= NULL
;
767 tcs
->usertraces
= NULL
;
769 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
770 fini((LttvTracesetContext
*)self
);
774 static LttvTracesetContext
*new_traceset_context(LttvTracesetContext
*self
)
776 return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE
, NULL
));
780 static LttvTraceContext
*new_trace_context(LttvTracesetContext
*self
)
782 return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE
, NULL
));
786 static LttvTracefileContext
*new_tracefile_context(LttvTracesetContext
*self
)
788 return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE
, NULL
));
792 /* Write the process state of the trace */
794 static void write_process_state(gpointer key
, gpointer value
,
797 LttvProcessState
*process
;
799 LttvExecutionState
*es
;
801 FILE *fp
= (FILE *)user_data
;
806 process
= (LttvProcessState
*)value
;
807 fprintf(fp
," <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\" FREE_EVENTS=\"%u\">\n",
808 process
, process
->pid
, process
->tgid
, process
->ppid
,
809 g_quark_to_string(process
->type
),
810 process
->creation_time
.tv_sec
,
811 process
->creation_time
.tv_nsec
,
812 process
->insertion_time
.tv_sec
,
813 process
->insertion_time
.tv_nsec
,
814 g_quark_to_string(process
->name
),
815 g_quark_to_string(process
->brand
),
816 process
->cpu
, process
->free_events
);
818 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
819 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
820 fprintf(fp
, " <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
821 g_quark_to_string(es
->t
), g_quark_to_string(es
->n
),
822 es
->entry
.tv_sec
, es
->entry
.tv_nsec
);
823 fprintf(fp
, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
824 es
->change
.tv_sec
, es
->change
.tv_nsec
, g_quark_to_string(es
->s
));
827 for(i
= 0 ; i
< process
->user_stack
->len
; i
++) {
828 address
= g_array_index(process
->user_stack
, guint64
, i
);
829 fprintf(fp
, " <USER_STACK ADDRESS=\"%" PRIu64
"\"/>\n", address
);
832 if(process
->usertrace
) {
833 fprintf(fp
, " <USERTRACE NAME=\"%s\" CPU=%u\n/>",
834 g_quark_to_string(process
->usertrace
->tracefile_name
),
835 process
->usertrace
->cpu
);
839 fprintf(fp
, " </PROCESS>\n");
843 void lttv_state_write(LttvTraceState
*self
, LttTime t
, FILE *fp
)
845 guint i
, nb_tracefile
, nb_block
, offset
;
848 LttvTracefileState
*tfcs
;
852 LttEventPosition
*ep
;
856 ep
= ltt_event_position_new();
858 fprintf(fp
,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t
.tv_sec
, t
.tv_nsec
);
860 g_hash_table_foreach(self
->processes
, write_process_state
, fp
);
862 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
863 for(i
=0;i
<nb_cpus
;i
++) {
864 fprintf(fp
," <CPU NUM=%u RUNNING_PROCESS=%u>\n",
865 i
, self
->running_process
[i
]->pid
);
868 nb_tracefile
= self
->parent
.tracefiles
->len
;
870 for(i
= 0 ; i
< nb_tracefile
; i
++) {
872 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
873 LttvTracefileContext
*, i
));
874 fprintf(fp
, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
875 tfcs
->parent
.timestamp
.tv_sec
,
876 tfcs
->parent
.timestamp
.tv_nsec
);
877 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
878 if(e
== NULL
) fprintf(fp
,"/>\n");
880 ltt_event_position(e
, ep
);
881 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
882 fprintf(fp
, " BLOCK=%u OFFSET=%u TSC=%" PRIu64
"/>\n", nb_block
, offset
,
887 fprintf(fp
,"</PROCESS_STATE>\n");
891 static void write_process_state_raw(gpointer key
, gpointer value
,
894 LttvProcessState
*process
;
896 LttvExecutionState
*es
;
898 FILE *fp
= (FILE *)user_data
;
903 process
= (LttvProcessState
*)value
;
904 fputc(HDR_PROCESS
, fp
);
905 //fwrite(&header, sizeof(header), 1, fp);
906 //fprintf(fp, "%s", g_quark_to_string(process->type));
908 fwrite(&process
->type
, sizeof(process
->type
), 1, fp
);
909 //fprintf(fp, "%s", g_quark_to_string(process->name));
911 fwrite(&process
->name
, sizeof(process
->name
), 1, fp
);
912 //fprintf(fp, "%s", g_quark_to_string(process->brand));
914 fwrite(&process
->brand
, sizeof(process
->brand
), 1, fp
);
915 fwrite(&process
->pid
, sizeof(process
->pid
), 1, fp
);
916 fwrite(&process
->free_events
, sizeof(process
->free_events
), 1, fp
);
917 fwrite(&process
->tgid
, sizeof(process
->tgid
), 1, fp
);
918 fwrite(&process
->ppid
, sizeof(process
->ppid
), 1, fp
);
919 fwrite(&process
->cpu
, sizeof(process
->cpu
), 1, fp
);
920 fwrite(&process
->creation_time
, sizeof(process
->creation_time
), 1, fp
);
921 fwrite(&process
->insertion_time
, sizeof(process
->insertion_time
), 1, fp
);
924 fprintf(fp
," <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",
925 process
, process
->pid
, process
->tgid
, process
->ppid
,
926 g_quark_to_string(process
->type
),
927 process
->creation_time
.tv_sec
,
928 process
->creation_time
.tv_nsec
,
929 process
->insertion_time
.tv_sec
,
930 process
->insertion_time
.tv_nsec
,
931 g_quark_to_string(process
->name
),
932 g_quark_to_string(process
->brand
),
936 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
937 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
940 //fprintf(fp, "%s", g_quark_to_string(es->t));
942 fwrite(&es
->t
, sizeof(es
->t
), 1, fp
);
943 //fprintf(fp, "%s", g_quark_to_string(es->n));
945 fwrite(&es
->n
, sizeof(es
->n
), 1, fp
);
946 //fprintf(fp, "%s", g_quark_to_string(es->s));
948 fwrite(&es
->s
, sizeof(es
->s
), 1, fp
);
949 fwrite(&es
->entry
, sizeof(es
->entry
), 1, fp
);
950 fwrite(&es
->change
, sizeof(es
->change
), 1, fp
);
951 fwrite(&es
->cum_cpu_time
, sizeof(es
->cum_cpu_time
), 1, fp
);
953 fprintf(fp
, " <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
954 g_quark_to_string(es
->t
), g_quark_to_string(es
->n
),
955 es
->entry
.tv_sec
, es
->entry
.tv_nsec
);
956 fprintf(fp
, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
957 es
->change
.tv_sec
, es
->change
.tv_nsec
, g_quark_to_string(es
->s
));
961 for(i
= 0 ; i
< process
->user_stack
->len
; i
++) {
962 address
= g_array_index(process
->user_stack
, guint64
, i
);
963 fputc(HDR_USER_STACK
, fp
);
964 fwrite(&address
, sizeof(address
), 1, fp
);
966 fprintf(fp
, " <USER_STACK ADDRESS=\"%llu\"/>\n", address
);
970 if(process
->usertrace
) {
971 fputc(HDR_USERTRACE
, fp
);
972 //fprintf(fp, "%s", g_quark_to_string(process->usertrace->tracefile_name));
974 fwrite(&process
->usertrace
->tracefile_name
,
975 sizeof(process
->usertrace
->tracefile_name
), 1, fp
);
976 fwrite(&process
->usertrace
->cpu
, sizeof(process
->usertrace
->cpu
), 1, fp
);
978 fprintf(fp
, " <USERTRACE NAME=\"%s\" CPU=%u\n/>",
979 g_quark_to_string(process
->usertrace
->tracefile_name
),
980 process
->usertrace
->cpu
);
987 void lttv_state_write_raw(LttvTraceState
*self
, LttTime t
, FILE *fp
)
989 guint i
, nb_tracefile
, nb_block
, offset
;
992 LttvTracefileState
*tfcs
;
996 LttEventPosition
*ep
;
1000 ep
= ltt_event_position_new();
1002 //fprintf(fp,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t.tv_sec, t.tv_nsec);
1003 fputc(HDR_PROCESS_STATE
, fp
);
1004 fwrite(&t
, sizeof(t
), 1, fp
);
1006 g_hash_table_foreach(self
->processes
, write_process_state_raw
, fp
);
1008 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
1009 for(i
=0;i
<nb_cpus
;i
++) {
1011 fwrite(&i
, sizeof(i
), 1, fp
); /* cpu number */
1012 fwrite(&self
->running_process
[i
]->pid
,
1013 sizeof(self
->running_process
[i
]->pid
), 1, fp
);
1014 //fprintf(fp," <CPU NUM=%u RUNNING_PROCESS=%u>\n",
1015 // i, self->running_process[i]->pid);
1018 nb_tracefile
= self
->parent
.tracefiles
->len
;
1020 for(i
= 0 ; i
< nb_tracefile
; i
++) {
1022 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
1023 LttvTracefileContext
*, i
));
1024 // fprintf(fp, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
1025 // tfcs->parent.timestamp.tv_sec,
1026 // tfcs->parent.timestamp.tv_nsec);
1027 fputc(HDR_TRACEFILE
, fp
);
1028 fwrite(&tfcs
->parent
.timestamp
, sizeof(tfcs
->parent
.timestamp
), 1, fp
);
1029 /* Note : if timestamp if LTT_TIME_INFINITE, there will be no
1030 * position following : end of trace */
1031 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
1033 ltt_event_position(e
, ep
);
1034 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
1035 //fprintf(fp, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block, offset,
1037 fwrite(&nb_block
, sizeof(nb_block
), 1, fp
);
1038 fwrite(&offset
, sizeof(offset
), 1, fp
);
1039 fwrite(&tsc
, sizeof(tsc
), 1, fp
);
1046 /* Read process state from a file */
1048 /* Called because a HDR_PROCESS was found */
1049 static void read_process_state_raw(LttvTraceState
*self
, FILE *fp
,
1050 GPtrArray
*quarktable
)
1052 LttvExecutionState
*es
;
1053 LttvProcessState
*process
, *parent_process
;
1054 LttvProcessState tmp
;
1059 /* TODO : check return value */
1060 fread(&tmp
.type
, sizeof(tmp
.type
), 1, fp
);
1061 fread(&tmp
.name
, sizeof(tmp
.name
), 1, fp
);
1062 fread(&tmp
.brand
, sizeof(tmp
.brand
), 1, fp
);
1063 fread(&tmp
.pid
, sizeof(tmp
.pid
), 1, fp
);
1064 fread(&tmp
.free_events
, sizeof(tmp
.free_events
), 1, fp
);
1065 fread(&tmp
.tgid
, sizeof(tmp
.tgid
), 1, fp
);
1066 fread(&tmp
.ppid
, sizeof(tmp
.ppid
), 1, fp
);
1067 fread(&tmp
.cpu
, sizeof(tmp
.cpu
), 1, fp
);
1068 fread(&tmp
.creation_time
, sizeof(tmp
.creation_time
), 1, fp
);
1069 fread(&tmp
.insertion_time
, sizeof(tmp
.insertion_time
), 1, fp
);
1072 process
= lttv_state_find_process(self
, tmp
.cpu
, tmp
.pid
);
1074 /* We must link to the parent */
1075 parent_process
= lttv_state_find_process_or_create(self
, ANY_CPU
, tmp
.ppid
,
1077 process
= lttv_state_find_process(self
, ANY_CPU
, tmp
.pid
);
1078 if(process
== NULL
) {
1079 process
= lttv_state_create_process(self
, parent_process
, tmp
.cpu
,
1081 g_quark_from_string((gchar
*)g_ptr_array_index(quarktable
, tmp
.name
)),
1082 &tmp
.creation_time
);
1085 process
->insertion_time
= tmp
.insertion_time
;
1086 process
->creation_time
= tmp
.creation_time
;
1087 process
->type
= g_quark_from_string(
1088 (gchar
*)g_ptr_array_index(quarktable
, tmp
.type
));
1089 process
->tgid
= tmp
.tgid
;
1090 process
->ppid
= tmp
.ppid
;
1091 process
->brand
= g_quark_from_string(
1092 (gchar
*)g_ptr_array_index(quarktable
, tmp
.brand
));
1094 g_quark_from_string((gchar
*)g_ptr_array_index(quarktable
, tmp
.name
));
1095 process
->free_events
= tmp
.free_events
;
1098 if(feof(fp
) || ferror(fp
)) goto end_loop
;
1100 gint hdr
= fgetc(fp
);
1101 if(hdr
== EOF
) goto end_loop
;
1105 process
->execution_stack
=
1106 g_array_set_size(process
->execution_stack
,
1107 process
->execution_stack
->len
+ 1);
1108 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
,
1109 process
->execution_stack
->len
-1);
1110 process
->state
= es
;
1112 fread(&es
->t
, sizeof(es
->t
), 1, fp
);
1113 es
->t
= g_quark_from_string(
1114 (gchar
*)g_ptr_array_index(quarktable
, es
->t
));
1115 fread(&es
->n
, sizeof(es
->n
), 1, fp
);
1116 es
->n
= g_quark_from_string(
1117 (gchar
*)g_ptr_array_index(quarktable
, es
->n
));
1118 fread(&es
->s
, sizeof(es
->s
), 1, fp
);
1119 es
->s
= g_quark_from_string(
1120 (gchar
*)g_ptr_array_index(quarktable
, es
->s
));
1121 fread(&es
->entry
, sizeof(es
->entry
), 1, fp
);
1122 fread(&es
->change
, sizeof(es
->change
), 1, fp
);
1123 fread(&es
->cum_cpu_time
, sizeof(es
->cum_cpu_time
), 1, fp
);
1126 case HDR_USER_STACK
:
1127 process
->user_stack
= g_array_set_size(process
->user_stack
,
1128 process
->user_stack
->len
+ 1);
1129 address
= &g_array_index(process
->user_stack
, guint64
,
1130 process
->user_stack
->len
-1);
1131 fread(address
, sizeof(address
), 1, fp
);
1132 process
->current_function
= *address
;
1136 fread(&tmpq
, sizeof(tmpq
), 1, fp
);
1137 fread(&process
->usertrace
->cpu
, sizeof(process
->usertrace
->cpu
), 1, fp
);
1150 /* Called because a HDR_PROCESS_STATE was found */
1151 /* Append a saved state to the trace states */
1152 void lttv_state_read_raw(LttvTraceState
*self
, FILE *fp
, GPtrArray
*quarktable
)
1154 guint i
, nb_tracefile
, nb_block
, offset
;
1156 LttvTracefileState
*tfcs
;
1158 LttEventPosition
*ep
;
1166 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
1168 LttvAttributeValue value
;
1169 GTree
*pqueue
= self
->parent
.ts_context
->pqueue
;
1170 ep
= ltt_event_position_new();
1172 restore_init_state(self
);
1174 fread(&t
, sizeof(t
), 1, fp
);
1177 if(feof(fp
) || ferror(fp
)) goto end_loop
;
1179 if(hdr
== EOF
) goto end_loop
;
1183 /* Call read_process_state_raw */
1184 read_process_state_raw(self
, fp
, quarktable
);
1192 case HDR_USER_STACK
:
1194 case HDR_PROCESS_STATE
:
1200 g_error("Error while parsing saved state file : unknown data header %d",
1206 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
1207 for(i
=0;i
<nb_cpus
;i
++) {
1210 g_assert(hdr
== HDR_CPU
);
1211 fread(&cpu_num
, sizeof(cpu_num
), 1, fp
); /* cpu number */
1212 g_assert(i
== cpu_num
);
1213 fread(&self
->running_process
[i
]->pid
,
1214 sizeof(self
->running_process
[i
]->pid
), 1, fp
);
1217 nb_tracefile
= self
->parent
.tracefiles
->len
;
1219 for(i
= 0 ; i
< nb_tracefile
; i
++) {
1221 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
1222 LttvTracefileContext
*, i
));
1223 // fprintf(fp, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
1224 // tfcs->parent.timestamp.tv_sec,
1225 // tfcs->parent.timestamp.tv_nsec);
1226 g_tree_remove(pqueue
, &tfcs
->parent
);
1228 g_assert(hdr
== HDR_TRACEFILE
);
1229 fread(&tfcs
->parent
.timestamp
, sizeof(tfcs
->parent
.timestamp
), 1, fp
);
1230 /* Note : if timestamp if LTT_TIME_INFINITE, there will be no
1231 * position following : end of trace */
1232 if(ltt_time_compare(tfcs
->parent
.timestamp
, ltt_time_infinite
) != 0) {
1233 fread(&nb_block
, sizeof(nb_block
), 1, fp
);
1234 fread(&offset
, sizeof(offset
), 1, fp
);
1235 fread(&tsc
, sizeof(tsc
), 1, fp
);
1236 ltt_event_position_set(ep
, tfcs
->parent
.tf
, nb_block
, offset
, tsc
);
1237 gint ret
= ltt_tracefile_seek_position(tfcs
->parent
.tf
, ep
);
1239 g_tree_insert(pqueue
, &tfcs
->parent
, &tfcs
->parent
);
1244 saved_states_tree
= lttv_attribute_find_subdir(self
->parent
.t_a
,
1245 LTTV_STATE_SAVED_STATES
);
1246 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
1247 value
= lttv_attribute_add(saved_states_tree
,
1248 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
1249 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
1250 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
1251 *(value
.v_time
) = t
;
1252 lttv_state_save(self
, saved_state_tree
);
1253 g_debug("Saving state at time %lu.%lu", t
.tv_sec
,
1256 *(self
->max_time_state_recomputed_in_seek
) = t
;
1260 /* Called when a HDR_TRACE is found */
1261 void lttv_trace_states_read_raw(LttvTraceState
*tcs
, FILE *fp
,
1262 GPtrArray
*quarktable
)
1267 if(feof(fp
) || ferror(fp
)) goto end_loop
;
1269 if(hdr
== EOF
) goto end_loop
;
1272 case HDR_PROCESS_STATE
:
1273 /* Call read_process_state_raw */
1274 lttv_state_read_raw(tcs
, fp
, quarktable
);
1282 case HDR_USER_STACK
:
1286 g_error("Error while parsing saved state file :"
1287 " unexpected data header %d",
1291 g_error("Error while parsing saved state file : unknown data header %d",
1296 *(tcs
->max_time_state_recomputed_in_seek
) = tcs
->parent
.time_span
.end_time
;
1297 restore_init_state(tcs
);
1298 lttv_process_trace_seek_time(&tcs
->parent
, ltt_time_zero
);
1304 /* Copy each process from an existing hash table to a new one */
1306 static void copy_process_state(gpointer key
, gpointer value
,gpointer user_data
)
1308 LttvProcessState
*process
, *new_process
;
1310 GHashTable
*new_processes
= (GHashTable
*)user_data
;
1314 process
= (LttvProcessState
*)value
;
1315 new_process
= g_new(LttvProcessState
, 1);
1316 *new_process
= *process
;
1317 new_process
->execution_stack
= g_array_sized_new(FALSE
, FALSE
,
1318 sizeof(LttvExecutionState
), PREALLOCATED_EXECUTION_STACK
);
1319 new_process
->execution_stack
=
1320 g_array_set_size(new_process
->execution_stack
,
1321 process
->execution_stack
->len
);
1322 for(i
= 0 ; i
< process
->execution_stack
->len
; i
++) {
1323 g_array_index(new_process
->execution_stack
, LttvExecutionState
, i
) =
1324 g_array_index(process
->execution_stack
, LttvExecutionState
, i
);
1326 new_process
->state
= &g_array_index(new_process
->execution_stack
,
1327 LttvExecutionState
, new_process
->execution_stack
->len
- 1);
1328 new_process
->user_stack
= g_array_sized_new(FALSE
, FALSE
,
1329 sizeof(guint64
), 0);
1330 new_process
->user_stack
= g_array_set_size(new_process
->user_stack
,
1331 process
->user_stack
->len
);
1332 for(i
= 0 ; i
< process
->user_stack
->len
; i
++) {
1333 g_array_index(new_process
->user_stack
, guint64
, i
) =
1334 g_array_index(process
->user_stack
, guint64
, i
);
1336 new_process
->current_function
= process
->current_function
;
1338 /* fd hash table stuff */
1344 /* copy every item in the hash table */
1345 new_process
->fds
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
1347 g_hash_table_iter_init(&it
, process
->fds
);
1348 while (g_hash_table_iter_next (&it
, (void *)&key
, (void *)&value
)) {
1349 g_hash_table_insert(new_process
->fds
, key
, value
);
1353 /* When done creating the new process state, insert it in the
1355 g_hash_table_insert(new_processes
, new_process
, new_process
);
1359 static GHashTable
*lttv_state_copy_process_table(GHashTable
*processes
)
1361 GHashTable
*new_processes
= g_hash_table_new(process_hash
, process_equal
);
1363 g_hash_table_foreach(processes
, copy_process_state
, new_processes
);
1364 return new_processes
;
1367 static LttvCPUState
*lttv_state_copy_cpu_states(LttvCPUState
*states
, guint n
)
1370 LttvCPUState
*retval
;
1372 retval
= g_new(LttvCPUState
, n
);
1374 for(i
=0; i
<n
; i
++) {
1375 retval
[i
].irq_stack
= g_array_new(FALSE
, FALSE
, sizeof(gint
));
1376 g_array_set_size(retval
[i
].irq_stack
, states
[i
].irq_stack
->len
);
1377 for(j
=0; j
<states
[i
].irq_stack
->len
; j
++) {
1378 g_array_index(retval
[i
].irq_stack
, gint
, j
) =
1379 g_array_index(states
[i
].irq_stack
, gint
, j
);
1382 retval
[i
].softirq_stack
= g_array_new(FALSE
, FALSE
, sizeof(gint
));
1383 g_array_set_size(retval
[i
].softirq_stack
, states
[i
].softirq_stack
->len
);
1384 for(j
=0; j
<states
[i
].softirq_stack
->len
; j
++) {
1385 g_array_index(retval
[i
].softirq_stack
, gint
, j
) =
1386 g_array_index(states
[i
].softirq_stack
, gint
, j
);
1389 retval
[i
].trap_stack
= g_array_new(FALSE
, FALSE
, sizeof(gint
));
1390 g_array_set_size(retval
[i
].trap_stack
, states
[i
].trap_stack
->len
);
1391 for(j
=0; j
<states
[i
].trap_stack
->len
; j
++) {
1392 g_array_index(retval
[i
].trap_stack
, gint
, j
) =
1393 g_array_index(states
[i
].trap_stack
, gint
, j
);
1396 retval
[i
].mode_stack
= g_array_new(FALSE
, FALSE
, sizeof(LttvCPUMode
));
1397 g_array_set_size(retval
[i
].mode_stack
, states
[i
].mode_stack
->len
);
1398 for(j
=0; j
<states
[i
].mode_stack
->len
; j
++) {
1399 g_array_index(retval
[i
].mode_stack
, GQuark
, j
) =
1400 g_array_index(states
[i
].mode_stack
, GQuark
, j
);
1407 static void lttv_state_free_cpu_states(LttvCPUState
*states
, guint n
)
1411 for(i
=0; i
<n
; i
++) {
1412 g_array_free(states
[i
].mode_stack
, TRUE
);
1413 g_array_free(states
[i
].irq_stack
, TRUE
);
1414 g_array_free(states
[i
].softirq_stack
, TRUE
);
1415 g_array_free(states
[i
].trap_stack
, TRUE
);
1421 static LttvIRQState
*lttv_state_copy_irq_states(LttvIRQState
*states
, guint n
)
1424 LttvIRQState
*retval
;
1426 retval
= g_new(LttvIRQState
, n
);
1428 for(i
=0; i
<n
; i
++) {
1429 retval
[i
].mode_stack
= g_array_new(FALSE
, FALSE
, sizeof(LttvIRQMode
));
1430 g_array_set_size(retval
[i
].mode_stack
, states
[i
].mode_stack
->len
);
1431 for(j
=0; j
<states
[i
].mode_stack
->len
; j
++) {
1432 g_array_index(retval
[i
].mode_stack
, GQuark
, j
) =
1433 g_array_index(states
[i
].mode_stack
, GQuark
, j
);
1440 static void lttv_state_free_irq_states(LttvIRQState
*states
, guint n
)
1444 for(i
=0; i
<n
; i
++) {
1445 g_array_free(states
[i
].mode_stack
, TRUE
);
1451 static LttvSoftIRQState
*
1452 lttv_state_copy_soft_irq_states(LttvSoftIRQState
*states
, guint n
)
1455 LttvSoftIRQState
*retval
;
1457 retval
= g_new(LttvSoftIRQState
, n
);
1459 for(i
=0; i
<n
; i
++) {
1460 retval
[i
].pending
= states
[i
].pending
;
1461 retval
[i
].running
= states
[i
].running
;
1467 static void lttv_state_free_soft_irq_states(LttvSoftIRQState
*states
, guint n
)
1472 static LttvTrapState
*
1473 lttv_state_copy_trap_states(LttvTrapState
*states
, guint n
)
1476 LttvTrapState
*retval
;
1478 retval
= g_new(LttvTrapState
, n
);
1480 for(i
=0; i
<n
; i
++) {
1481 retval
[i
].running
= states
[i
].running
;
1487 static void lttv_state_free_trap_states(LttvTrapState
*states
, guint n
)
1492 /* bdevstate stuff */
1494 static LttvBdevState
*get_hashed_bdevstate(LttvTraceState
*ts
, guint32 devcode
)
1496 gint devcode_gint
= devcode
;
1497 printf("get_hashed_bdevstate devcode %d\n", devcode_gint
);
1498 gpointer bdev
= g_hash_table_lookup(ts
->bdev_states
, &devcode_gint
);
1500 LttvBdevState
*bdevstate
= g_new(LttvBdevState
, 1);
1501 bdevstate
->mode_stack
= g_array_new(FALSE
, FALSE
, sizeof(GQuark
));
1503 gint
* key
= g_new(gint
, 1);
1505 g_hash_table_insert(ts
->bdev_states
, key
, bdevstate
);
1513 static LttvBdevState
*bdevstate_new(void)
1515 LttvBdevState
*retval
;
1516 retval
= g_new(LttvBdevState
, 1);
1517 retval
->mode_stack
= g_array_new(FALSE
, FALSE
, sizeof(GQuark
));
1522 static void bdevstate_free(LttvBdevState
*bds
)
1524 g_array_free(bds
->mode_stack
, TRUE
);
1528 static void bdevstate_free_cb(gpointer key
, gpointer value
, gpointer user_data
)
1530 LttvBdevState
*bds
= (LttvBdevState
*) value
;
1532 bdevstate_free(bds
);
1535 static LttvBdevState
*bdevstate_copy(LttvBdevState
*bds
)
1537 LttvBdevState
*retval
;
1539 retval
= bdevstate_new();
1540 g_array_insert_vals(retval
->mode_stack
, 0, bds
->mode_stack
->data
,
1541 bds
->mode_stack
->len
);
1546 static void insert_and_copy_bdev_state(gpointer k
, gpointer v
, gpointer u
)
1548 //GHashTable *ht = (GHashTable *)u;
1549 LttvBdevState
*bds
= (LttvBdevState
*)v
;
1550 LttvBdevState
*newbds
;
1552 newbds
= bdevstate_copy(bds
);
1554 g_hash_table_insert(u
, k
, newbds
);
1557 static GHashTable
*lttv_state_copy_blkdev_hashtable(GHashTable
*ht
)
1561 retval
= g_hash_table_new(g_int_hash
, g_int_equal
);
1563 g_hash_table_foreach(ht
, insert_and_copy_bdev_state
, retval
);
1568 /* Free a hashtable and the LttvBdevState structures its values
1571 static void lttv_state_free_blkdev_hashtable(GHashTable
*ht
)
1573 g_hash_table_foreach(ht
, bdevstate_free_cb
, NULL
);
1574 g_hash_table_destroy(ht
);
1577 /* The saved state for each trace contains a member "processes", which
1578 stores a copy of the process table, and a member "tracefiles" with
1579 one entry per tracefile. Each tracefile has a "process" member pointing
1580 to the current process and a "position" member storing the tracefile
1581 position (needed to seek to the current "next" event. */
1583 static void state_save(LttvTraceState
*self
, LttvAttribute
*container
)
1585 guint i
, nb_tracefile
, nb_cpus
, nb_irqs
, nb_soft_irqs
, nb_traps
;
1587 LttvTracefileState
*tfcs
;
1589 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
1591 guint
*running_process
;
1593 LttvAttributeValue value
;
1595 LttEventPosition
*ep
;
1597 tracefiles_tree
= lttv_attribute_find_subdir(container
,
1598 LTTV_STATE_TRACEFILES
);
1600 value
= lttv_attribute_add(container
, LTTV_STATE_PROCESSES
,
1602 *(value
.v_pointer
) = lttv_state_copy_process_table(self
->processes
);
1604 /* Add the currently running processes array */
1605 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
1606 running_process
= g_new(guint
, nb_cpus
);
1607 for(i
=0;i
<nb_cpus
;i
++) {
1608 running_process
[i
] = self
->running_process
[i
]->pid
;
1610 value
= lttv_attribute_add(container
, LTTV_STATE_RUNNING_PROCESS
,
1612 *(value
.v_pointer
) = running_process
;
1614 g_info("State save");
1616 nb_tracefile
= self
->parent
.tracefiles
->len
;
1618 for(i
= 0 ; i
< nb_tracefile
; i
++) {
1620 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
1621 LttvTracefileContext
*, i
));
1622 tracefile_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
1623 value
= lttv_attribute_add(tracefiles_tree
, i
,
1625 *(value
.v_gobject
) = (GObject
*)tracefile_tree
;
1627 value
= lttv_attribute_add(tracefile_tree
, LTTV_STATE_PROCESS
,
1629 *(value
.v_uint
) = tfcs
->process
->pid
;
1631 value
= lttv_attribute_add(tracefile_tree
, LTTV_STATE_EVENT
,
1633 /* Only save the position if the tfs has not infinite time. */
1634 //if(!g_tree_lookup(self->parent.ts_context->pqueue, &tfcs->parent)
1635 // && current_tfcs != tfcs) {
1636 if(ltt_time_compare(tfcs
->parent
.timestamp
, ltt_time_infinite
) == 0) {
1637 *(value
.v_pointer
) = NULL
;
1639 LttEvent
*e
= ltt_tracefile_get_event(tfcs
->parent
.tf
);
1640 ep
= ltt_event_position_new();
1641 ltt_event_position(e
, ep
);
1642 *(value
.v_pointer
) = ep
;
1644 guint nb_block
, offset
;
1647 ltt_event_position_get(ep
, &tf
, &nb_block
, &offset
, &tsc
);
1648 g_info("Block %u offset %u tsc %" PRIu64
" time %lu.%lu", nb_block
,
1649 offset
, tsc
, tfcs
->parent
.timestamp
.tv_sec
,
1650 tfcs
->parent
.timestamp
.tv_nsec
);
1654 /* save the cpu state */
1656 value
= lttv_attribute_add(container
, LTTV_STATE_RESOURCE_CPUS_COUNT
,
1658 *(value
.v_uint
) = nb_cpus
;
1660 value
= lttv_attribute_add(container
, LTTV_STATE_RESOURCE_CPUS
,
1662 *(value
.v_pointer
) = lttv_state_copy_cpu_states(self
->cpu_states
, nb_cpus
);
1665 /* save the irq state */
1666 nb_irqs
= self
->name_tables
->nb_irqs
;
1668 value
= lttv_attribute_add(container
, LTTV_STATE_RESOURCE_IRQS
,
1670 *(value
.v_pointer
) = lttv_state_copy_irq_states(self
->irq_states
, nb_irqs
);
1673 /* save the soft irq state */
1674 nb_soft_irqs
= self
->name_tables
->nb_soft_irqs
;
1676 value
= lttv_attribute_add(container
, LTTV_STATE_RESOURCE_SOFT_IRQS
,
1678 *(value
.v_pointer
) = lttv_state_copy_soft_irq_states(self
->soft_irq_states
, nb_soft_irqs
);
1681 /* save the trap state */
1682 nb_traps
= self
->name_tables
->nb_traps
;
1684 value
= lttv_attribute_add(container
, LTTV_STATE_RESOURCE_TRAPS
,
1686 *(value
.v_pointer
) = lttv_state_copy_trap_states(self
->trap_states
, nb_traps
);
1689 /* save the blkdev states */
1690 value
= lttv_attribute_add(container
, LTTV_STATE_RESOURCE_BLKDEVS
,
1692 *(value
.v_pointer
) = lttv_state_copy_blkdev_hashtable(self
->bdev_states
);
1696 static void state_restore(LttvTraceState
*self
, LttvAttribute
*container
)
1698 guint i
, nb_tracefile
, pid
, nb_cpus
, nb_irqs
, nb_soft_irqs
, nb_traps
;
1700 LttvTracefileState
*tfcs
;
1702 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
1704 guint
*running_process
;
1706 LttvAttributeType type
;
1708 LttvAttributeValue value
;
1710 LttvAttributeName name
;
1714 LttEventPosition
*ep
;
1716 LttvTracesetContext
*tsc
= self
->parent
.ts_context
;
1719 tracefiles_tree
= lttv_attribute_find_subdir(container
,
1720 LTTV_STATE_TRACEFILES
);
1722 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_PROCESSES
,
1724 g_assert(type
== LTTV_POINTER
);
1725 lttv_state_free_process_table(self
->processes
);
1726 self
->processes
= lttv_state_copy_process_table(*(value
.v_pointer
));
1728 /* Add the currently running processes array */
1729 nb_cpus
= ltt_trace_get_num_cpu(self
->parent
.t
);
1730 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RUNNING_PROCESS
,
1732 g_assert(type
== LTTV_POINTER
);
1733 running_process
= *(value
.v_pointer
);
1734 for(i
=0;i
<nb_cpus
;i
++) {
1735 pid
= running_process
[i
];
1736 self
->running_process
[i
] = lttv_state_find_process(self
, i
, pid
);
1737 g_assert(self
->running_process
[i
] != NULL
);
1740 nb_tracefile
= self
->parent
.tracefiles
->len
;
1742 //g_tree_destroy(tsc->pqueue);
1743 //tsc->pqueue = g_tree_new(compare_tracefile);
1745 /* restore cpu resource states */
1746 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RESOURCE_CPUS
, &value
);
1747 g_assert(type
== LTTV_POINTER
);
1748 lttv_state_free_cpu_states(self
->cpu_states
, nb_cpus
);
1749 self
->cpu_states
= lttv_state_copy_cpu_states(*(value
.v_pointer
), nb_cpus
);
1751 /* restore irq resource states */
1752 nb_irqs
= self
->name_tables
->nb_irqs
;
1753 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RESOURCE_IRQS
, &value
);
1754 g_assert(type
== LTTV_POINTER
);
1755 lttv_state_free_irq_states(self
->irq_states
, nb_irqs
);
1756 self
->irq_states
= lttv_state_copy_irq_states(*(value
.v_pointer
), nb_irqs
);
1758 /* restore soft irq resource states */
1759 nb_soft_irqs
= self
->name_tables
->nb_soft_irqs
;
1760 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RESOURCE_SOFT_IRQS
, &value
);
1761 g_assert(type
== LTTV_POINTER
);
1762 lttv_state_free_soft_irq_states(self
->soft_irq_states
, nb_soft_irqs
);
1763 self
->soft_irq_states
= lttv_state_copy_soft_irq_states(*(value
.v_pointer
), nb_soft_irqs
);
1765 /* restore trap resource states */
1766 nb_traps
= self
->name_tables
->nb_traps
;
1767 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RESOURCE_TRAPS
, &value
);
1768 g_assert(type
== LTTV_POINTER
);
1769 lttv_state_free_trap_states(self
->trap_states
, nb_traps
);
1770 self
->trap_states
= lttv_state_copy_trap_states(*(value
.v_pointer
), nb_traps
);
1772 /* restore the blkdev states */
1773 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RESOURCE_BLKDEVS
, &value
);
1774 g_assert(type
== LTTV_POINTER
);
1775 lttv_state_free_blkdev_hashtable(self
->bdev_states
);
1776 self
->bdev_states
= lttv_state_copy_blkdev_hashtable(*(value
.v_pointer
));
1778 for(i
= 0 ; i
< nb_tracefile
; i
++) {
1780 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
1781 LttvTracefileContext
*, i
));
1782 type
= lttv_attribute_get(tracefiles_tree
, i
, &name
, &value
, &is_named
);
1783 g_assert(type
== LTTV_GOBJECT
);
1784 tracefile_tree
= *((LttvAttribute
**)(value
.v_gobject
));
1786 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_PROCESS
,
1788 g_assert(type
== LTTV_UINT
);
1789 pid
= *(value
.v_uint
);
1790 tfcs
->process
= lttv_state_find_process_or_create(tfcs
, pid
);
1792 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_EVENT
,
1794 g_assert(type
== LTTV_POINTER
);
1795 //g_assert(*(value.v_pointer) != NULL);
1796 ep
= *(value
.v_pointer
);
1797 g_assert(tfcs
->parent
.t_context
!= NULL
);
1799 tfcs
->cpu_state
= &self
->cpu_states
[tfcs
->cpu
];
1801 LttvTracefileContext
*tfc
= LTTV_TRACEFILE_CONTEXT(tfcs
);
1802 g_tree_remove(tsc
->pqueue
, tfc
);
1805 retval
= ltt_tracefile_seek_position(tfc
->tf
, ep
);
1806 g_assert_cmpint(retval
, ==, 0);
1807 tfc
->timestamp
= ltt_event_time(ltt_tracefile_get_event(tfc
->tf
));
1808 g_assert_cmpint(ltt_time_compare(tfc
->timestamp
, ltt_time_infinite
),
1810 g_tree_insert(tsc
->pqueue
, tfc
, tfc
);
1811 g_info("Restoring state for a tf at time %lu.%lu",
1812 tfc
->timestamp
.tv_sec
, tfc
->timestamp
.tv_nsec
);
1814 tfc
->timestamp
= ltt_time_infinite
;
1820 static void state_saved_free(LttvTraceState
*self
, LttvAttribute
*container
)
1822 guint i
, nb_tracefile
, nb_cpus
, nb_irqs
, nb_soft_irqs
;
1824 LttvTracefileState
*tfcs
;
1826 LttvAttribute
*tracefiles_tree
, *tracefile_tree
;
1828 guint
*running_process
;
1830 LttvAttributeType type
;
1832 LttvAttributeValue value
;
1834 LttvAttributeName name
;
1838 tracefiles_tree
= lttv_attribute_find_subdir(container
,
1839 LTTV_STATE_TRACEFILES
);
1840 g_object_ref(G_OBJECT(tracefiles_tree
));
1841 lttv_attribute_remove_by_name(container
, LTTV_STATE_TRACEFILES
);
1843 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_PROCESSES
,
1845 g_assert(type
== LTTV_POINTER
);
1846 lttv_state_free_process_table(*(value
.v_pointer
));
1847 *(value
.v_pointer
) = NULL
;
1848 lttv_attribute_remove_by_name(container
, LTTV_STATE_PROCESSES
);
1850 /* Free running processes array */
1851 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RUNNING_PROCESS
,
1853 g_assert(type
== LTTV_POINTER
);
1854 running_process
= *(value
.v_pointer
);
1855 g_free(running_process
);
1857 /* free cpu resource states */
1858 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RESOURCE_CPUS_COUNT
, &value
);
1859 g_assert(type
== LTTV_UINT
);
1860 nb_cpus
= *value
.v_uint
;
1861 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RESOURCE_CPUS
, &value
);
1862 g_assert(type
== LTTV_POINTER
);
1863 lttv_state_free_cpu_states(*(value
.v_pointer
), nb_cpus
);
1865 /* free irq resource states */
1866 nb_irqs
= self
->name_tables
->nb_irqs
;
1867 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RESOURCE_IRQS
, &value
);
1868 g_assert(type
== LTTV_POINTER
);
1869 lttv_state_free_irq_states(*(value
.v_pointer
), nb_irqs
);
1871 /* free softirq resource states */
1872 nb_soft_irqs
= self
->name_tables
->nb_soft_irqs
;
1873 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RESOURCE_SOFT_IRQS
, &value
);
1874 g_assert(type
== LTTV_POINTER
);
1875 lttv_state_free_soft_irq_states(*(value
.v_pointer
), nb_soft_irqs
);
1877 /* free the blkdev states */
1878 type
= lttv_attribute_get_by_name(container
, LTTV_STATE_RESOURCE_BLKDEVS
, &value
);
1879 g_assert(type
== LTTV_POINTER
);
1880 lttv_state_free_blkdev_hashtable(*(value
.v_pointer
));
1882 nb_tracefile
= self
->parent
.tracefiles
->len
;
1884 for(i
= 0 ; i
< nb_tracefile
; i
++) {
1886 LTTV_TRACEFILE_STATE(g_array_index(self
->parent
.tracefiles
,
1887 LttvTracefileContext
*, i
));
1888 type
= lttv_attribute_get(tracefiles_tree
, i
, &name
, &value
, &is_named
);
1889 g_assert(type
== LTTV_GOBJECT
);
1890 tracefile_tree
= *((LttvAttribute
**)(value
.v_gobject
));
1892 type
= lttv_attribute_get_by_name(tracefile_tree
, LTTV_STATE_EVENT
,
1894 g_assert(type
== LTTV_POINTER
);
1895 if(*(value
.v_pointer
) != NULL
) g_free(*(value
.v_pointer
));
1897 g_object_unref(G_OBJECT(tracefiles_tree
));
1901 static void free_saved_state(LttvTraceState
*self
)
1905 LttvAttributeType type
;
1907 LttvAttributeValue value
;
1909 LttvAttributeName name
;
1913 LttvAttribute
*saved_states
;
1915 saved_states
= lttv_attribute_find_subdir(self
->parent
.t_a
,
1916 LTTV_STATE_SAVED_STATES
);
1918 nb
= lttv_attribute_get_number(saved_states
);
1919 for(i
= 0 ; i
< nb
; i
++) {
1920 type
= lttv_attribute_get(saved_states
, i
, &name
, &value
, &is_named
);
1921 g_assert(type
== LTTV_GOBJECT
);
1922 state_saved_free(self
, *((LttvAttribute
**)value
.v_gobject
));
1925 lttv_attribute_remove_by_name(self
->parent
.t_a
, LTTV_STATE_SAVED_STATES
);
1929 static void create_max_time(LttvTraceState
*tcs
)
1931 LttvAttributeValue v
;
1933 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
1935 g_assert(*(v
.v_pointer
) == NULL
);
1936 *(v
.v_pointer
) = g_new(LttTime
,1);
1937 *((LttTime
*)*(v
.v_pointer
)) = ltt_time_zero
;
1941 static void get_max_time(LttvTraceState
*tcs
)
1943 LttvAttributeValue v
;
1945 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
1947 g_assert(*(v
.v_pointer
) != NULL
);
1948 tcs
->max_time_state_recomputed_in_seek
= (LttTime
*)*(v
.v_pointer
);
1952 static void free_max_time(LttvTraceState
*tcs
)
1954 LttvAttributeValue v
;
1956 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_SAVED_STATES_TIME
,
1958 g_free(*(v
.v_pointer
));
1959 *(v
.v_pointer
) = NULL
;
1962 static void create_name_tables(LttvTraceState
*tcs
)
1966 GString
*fe_name
= g_string_new("");
1968 LttvNameTables
*name_tables
= g_new(LttvNameTables
, 1);
1970 LttvAttributeValue v
;
1974 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
1976 g_assert(*(v
.v_pointer
) == NULL
);
1977 *(v
.v_pointer
) = name_tables
;
1979 hooks
= g_array_sized_new(FALSE
, FALSE
, sizeof(LttvTraceHook
), 1);
1981 if(!lttv_trace_find_hook(tcs
->parent
.t
,
1983 LTT_EVENT_SYSCALL_ENTRY
,
1984 FIELD_ARRAY(LTT_FIELD_SYSCALL_ID
),
1985 NULL
, NULL
, &hooks
)) {
1987 // th = lttv_trace_hook_get_first(&th);
1989 // t = ltt_field_type(lttv_trace_get_hook_field(th, 0));
1990 // nb = ltt_type_element_number(t);
1992 // name_tables->syscall_names = g_new(GQuark, nb);
1993 // name_tables->nb_syscalls = nb;
1995 // for(i = 0 ; i < nb ; i++) {
1996 // name_tables->syscall_names[i] = ltt_enum_string_get(t, i);
1997 // if(!name_tables->syscall_names[i]) {
1998 // GString *string = g_string_new("");
1999 // g_string_printf(string, "syscall %u", i);
2000 // name_tables->syscall_names[i] = g_quark_from_string(string->str);
2001 // g_string_free(string, TRUE);
2005 name_tables
->nb_syscalls
= 256;
2006 name_tables
->syscall_names
= g_new(GQuark
, 256);
2007 for(i
= 0 ; i
< 256 ; i
++) {
2008 g_string_printf(fe_name
, "syscall %d", i
);
2009 name_tables
->syscall_names
[i
] = g_quark_from_string(fe_name
->str
);
2012 name_tables
->syscall_names
= NULL
;
2013 name_tables
->nb_syscalls
= 0;
2015 lttv_trace_hook_remove_all(&hooks
);
2017 if(!lttv_trace_find_hook(tcs
->parent
.t
,
2019 LTT_EVENT_TRAP_ENTRY
,
2020 FIELD_ARRAY(LTT_FIELD_TRAP_ID
),
2021 NULL
, NULL
, &hooks
) ||
2022 !lttv_trace_find_hook(tcs
->parent
.t
,
2024 LTT_EVENT_PAGE_FAULT_ENTRY
,
2025 FIELD_ARRAY(LTT_FIELD_TRAP_ID
),
2026 NULL
, NULL
, &hooks
)) {
2028 // th = lttv_trace_hook_get_first(&th);
2030 // t = ltt_field_type(lttv_trace_get_hook_field(th, 0));
2031 // //nb = ltt_type_element_number(t);
2033 // name_tables->trap_names = g_new(GQuark, nb);
2034 // for(i = 0 ; i < nb ; i++) {
2035 // name_tables->trap_names[i] = g_quark_from_string(
2036 // ltt_enum_string_get(t, i));
2039 name_tables
->nb_traps
= 256;
2040 name_tables
->trap_names
= g_new(GQuark
, 256);
2041 for(i
= 0 ; i
< 256 ; i
++) {
2042 g_string_printf(fe_name
, "trap %d", i
);
2043 name_tables
->trap_names
[i
] = g_quark_from_string(fe_name
->str
);
2046 name_tables
->trap_names
= NULL
;
2047 name_tables
->nb_traps
= 0;
2049 lttv_trace_hook_remove_all(&hooks
);
2051 if(!lttv_trace_find_hook(tcs
->parent
.t
,
2053 LTT_EVENT_IRQ_ENTRY
,
2054 FIELD_ARRAY(LTT_FIELD_IRQ_ID
),
2055 NULL
, NULL
, &hooks
)) {
2058 name_tables->irq_names = g_new(GQuark, nb);
2059 for(i = 0 ; i < nb ; i++) {
2060 name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
2063 /* FIXME: LttvIRQState *irq_states should become a g_array */
2064 /* temp fix: increase from 256 to 512 default size */
2066 name_tables
->nb_irqs
= 512;
2067 name_tables
->irq_names
= g_new(GQuark
, 512);
2068 for(i
= 0 ; i
< 512 ; i
++) {
2069 g_string_printf(fe_name
, "irq %d", i
);
2070 name_tables
->irq_names
[i
] = g_quark_from_string(fe_name
->str
);
2073 name_tables
->nb_irqs
= 0;
2074 name_tables
->irq_names
= NULL
;
2076 lttv_trace_hook_remove_all(&hooks
);
2078 name_tables->soft_irq_names = g_new(GQuark, nb);
2079 for(i = 0 ; i < nb ; i++) {
2080 name_tables->soft_irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
2084 /* the kernel is limited to 32 statically defined softirqs */
2085 name_tables
->nb_soft_irqs
= 32;
2086 name_tables
->soft_irq_names
= g_new(GQuark
, name_tables
->nb_soft_irqs
);
2087 for(i
= 0 ; i
< name_tables
->nb_soft_irqs
; i
++) {
2088 g_string_printf(fe_name
, "softirq %d", i
);
2089 name_tables
->soft_irq_names
[i
] = g_quark_from_string(fe_name
->str
);
2091 g_array_free(hooks
, TRUE
);
2093 g_string_free(fe_name
, TRUE
);
2095 #if (__WORDSIZE == 32)
2096 name_tables
->kprobe_hash
= g_hash_table_new_full(guint64_hash
, guint64_equal
,
2099 name_tables
->kprobe_hash
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
2104 static void get_name_tables(LttvTraceState
*tcs
)
2106 LttvAttributeValue v
;
2108 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
2110 g_assert(*(v
.v_pointer
) != NULL
);
2111 tcs
->name_tables
= (LttvNameTables
*)*(v
.v_pointer
);
2115 static void free_name_tables(LttvTraceState
*tcs
)
2117 LttvNameTables
*name_tables
;
2119 LttvAttributeValue v
;
2121 lttv_attribute_find(tcs
->parent
.t_a
, LTTV_STATE_NAME_TABLES
,
2123 name_tables
= (LttvNameTables
*)*(v
.v_pointer
);
2124 *(v
.v_pointer
) = NULL
;
2126 // g_free(name_tables->eventtype_names);
2127 if(name_tables
->syscall_names
) g_free(name_tables
->syscall_names
);
2128 if(name_tables
->trap_names
) g_free(name_tables
->trap_names
);
2129 if(name_tables
->irq_names
) g_free(name_tables
->irq_names
);
2130 if(name_tables
->soft_irq_names
) g_free(name_tables
->soft_irq_names
);
2131 g_hash_table_destroy(name_tables
->kprobe_hash
);
2132 g_free(name_tables
);
2135 #ifdef HASH_TABLE_DEBUG
2137 static void test_process(gpointer key
, gpointer value
, gpointer user_data
)
2139 LttvProcessState
*process
= (LttvProcessState
*)value
;
2141 /* Test for process corruption */
2142 guint stack_len
= process
->execution_stack
->len
;
2145 static void hash_table_check(GHashTable
*table
)
2147 g_hash_table_foreach(table
, test_process
, NULL
);
2153 /* clears the stack and sets the state passed as argument */
2154 static void cpu_set_base_mode(LttvCPUState
*cpust
, LttvCPUMode state
)
2156 g_array_set_size(cpust
->mode_stack
, 1);
2157 ((GQuark
*)cpust
->mode_stack
->data
)[0] = state
;
2160 static void cpu_push_mode(LttvCPUState
*cpust
, LttvCPUMode state
)
2162 g_array_set_size(cpust
->mode_stack
, cpust
->mode_stack
->len
+ 1);
2163 ((GQuark
*)cpust
->mode_stack
->data
)[cpust
->mode_stack
->len
- 1] = state
;
2166 static void cpu_pop_mode(LttvCPUState
*cpust
)
2168 if(cpust
->mode_stack
->len
<= 1)
2169 cpu_set_base_mode(cpust
, LTTV_CPU_UNKNOWN
);
2171 g_array_set_size(cpust
->mode_stack
, cpust
->mode_stack
->len
- 1);
2174 /* clears the stack and sets the state passed as argument */
2175 static void bdev_set_base_mode(LttvBdevState
*bdevst
, LttvBdevMode state
)
2177 g_array_set_size(bdevst
->mode_stack
, 1);
2178 ((GQuark
*)bdevst
->mode_stack
->data
)[0] = state
;
2181 static void bdev_push_mode(LttvBdevState
*bdevst
, LttvBdevMode state
)
2183 g_array_set_size(bdevst
->mode_stack
, bdevst
->mode_stack
->len
+ 1);
2184 ((GQuark
*)bdevst
->mode_stack
->data
)[bdevst
->mode_stack
->len
- 1] = state
;
2187 static void bdev_pop_mode(LttvBdevState
*bdevst
)
2189 if(bdevst
->mode_stack
->len
<= 1)
2190 bdev_set_base_mode(bdevst
, LTTV_BDEV_UNKNOWN
);
2192 g_array_set_size(bdevst
->mode_stack
, bdevst
->mode_stack
->len
- 1);
2195 static void irq_set_base_mode(LttvIRQState
*irqst
, LttvIRQMode state
)
2197 g_array_set_size(irqst
->mode_stack
, 1);
2198 ((GQuark
*)irqst
->mode_stack
->data
)[0] = state
;
2201 static void irq_push_mode(LttvIRQState
*irqst
, LttvIRQMode state
)
2203 g_array_set_size(irqst
->mode_stack
, irqst
->mode_stack
->len
+ 1);
2204 ((GQuark
*)irqst
->mode_stack
->data
)[irqst
->mode_stack
->len
- 1] = state
;
2207 static void irq_pop_mode(LttvIRQState
*irqst
)
2209 if(irqst
->mode_stack
->len
<= 1)
2210 irq_set_base_mode(irqst
, LTTV_IRQ_UNKNOWN
);
2212 g_array_set_size(irqst
->mode_stack
, irqst
->mode_stack
->len
- 1);
2215 static void push_state(LttvTracefileState
*tfs
, LttvExecutionMode t
,
2218 LttvExecutionState
*es
;
2220 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
2221 guint cpu
= tfs
->cpu
;
2223 #ifdef HASH_TABLE_DEBUG
2224 hash_table_check(ts
->processes
);
2226 LttvProcessState
*process
= ts
->running_process
[cpu
];
2228 guint depth
= process
->execution_stack
->len
;
2230 process
->execution_stack
=
2231 g_array_set_size(process
->execution_stack
, depth
+ 1);
2234 &g_array_index(process
->execution_stack
, LttvExecutionState
, depth
- 1);
2236 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, depth
);
2239 es
->entry
= es
->change
= tfs
->parent
.timestamp
;
2240 es
->cum_cpu_time
= ltt_time_zero
;
2241 es
->s
= process
->state
->s
;
2242 process
->state
= es
;
2246 * return 1 when empty, else 0 */
2248 lttv_state_pop_state_cleanup(LttvProcessState
*process
, LttvTracefileState
*tfs
)
2250 guint depth
= process
->execution_stack
->len
;
2256 process
->execution_stack
=
2257 g_array_set_size(process
->execution_stack
, depth
- 1);
2258 process
->state
= &g_array_index(process
->execution_stack
, LttvExecutionState
,
2260 process
->state
->change
= tfs
->parent
.timestamp
;
2265 static void pop_state(LttvTracefileState
*tfs
, LttvExecutionMode t
)
2267 guint cpu
= tfs
->cpu
;
2268 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
2269 LttvProcessState
*process
= ts
->running_process
[cpu
];
2271 guint depth
= process
->execution_stack
->len
;
2273 if(process
->state
->t
!= t
){
2274 g_info("Different execution mode type (%lu.%09lu): ignore it\n",
2275 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
2276 g_info("process state has %s when pop_int is %s\n",
2277 g_quark_to_string(process
->state
->t
),
2278 g_quark_to_string(t
));
2279 g_info("{ %u, %u, %s, %s, %s }\n",
2282 g_quark_to_string(process
->name
),
2283 g_quark_to_string(process
->brand
),
2284 g_quark_to_string(process
->state
->s
));
2289 g_info("Trying to pop last state on stack (%lu.%09lu): ignore it\n",
2290 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
2294 process
->execution_stack
=
2295 g_array_set_size(process
->execution_stack
, depth
- 1);
2296 process
->state
= &g_array_index(process
->execution_stack
, LttvExecutionState
,
2298 process
->state
->change
= tfs
->parent
.timestamp
;
2301 struct search_result
{
2302 const LttTime
*time
; /* Requested time */
2303 LttTime
*best
; /* Best result */
2306 static gint
search_usertrace(gconstpointer a
, gconstpointer b
)
2308 const LttTime
*elem_time
= (const LttTime
*)a
;
2309 /* Explicit non const cast */
2310 struct search_result
*res
= (struct search_result
*)b
;
2312 if(ltt_time_compare(*elem_time
, *(res
->time
)) < 0) {
2313 /* The usertrace was created before the schedchange */
2314 /* Get larger keys */
2316 } else if(ltt_time_compare(*elem_time
, *(res
->time
)) >= 0) {
2317 /* The usertrace was created after the schedchange time */
2318 /* Get smaller keys */
2320 if(ltt_time_compare(*elem_time
, *res
->best
) < 0) {
2321 res
->best
= (LttTime
*)elem_time
;
2324 res
->best
= (LttTime
*)elem_time
;
2331 static LttvTracefileState
*ltt_state_usertrace_find(LttvTraceState
*tcs
,
2332 guint pid
, const LttTime
*timestamp
)
2334 LttvTracefileState
*tfs
= NULL
;
2335 struct search_result res
;
2336 /* Find the usertrace associated with a pid and time interval.
2337 * Search in the usertraces by PID (within a hash) and then, for each
2338 * corresponding element of the array, find the first one with creation
2339 * timestamp the lowest, but higher or equal to "timestamp". */
2340 res
.time
= timestamp
;
2342 GTree
*usertrace_tree
= g_hash_table_lookup(tcs
->usertraces
,
2343 GUINT_TO_POINTER(pid
));
2344 if(usertrace_tree
) {
2345 g_tree_search(usertrace_tree
, search_usertrace
, &res
);
2347 tfs
= g_tree_lookup(usertrace_tree
, res
.best
);
2353 /* Return a new and initialized LttvProcessState structure */
2355 LttvProcessState
*lttv_state_create_process(LttvTraceState
*tcs
,
2356 LttvProcessState
*parent
, guint cpu
, guint pid
,
2357 guint tgid
, GQuark name
, const LttTime
*timestamp
)
2359 LttvProcessState
*process
= g_new(LttvProcessState
, 1);
2361 LttvExecutionState
*es
;
2366 process
->tgid
= tgid
;
2368 process
->name
= name
;
2369 process
->brand
= LTTV_STATE_UNBRANDED
;
2370 //process->last_cpu = tfs->cpu_name;
2371 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
2372 process
->type
= LTTV_STATE_USER_THREAD
;
2373 process
->usertrace
= ltt_state_usertrace_find(tcs
, pid
, timestamp
);
2374 process
->current_function
= 0; //function 0x0 by default.
2376 g_info("Process %u, core %p", process
->pid
, process
);
2377 g_hash_table_insert(tcs
->processes
, process
, process
);
2380 process
->ppid
= parent
->pid
;
2381 process
->creation_time
= *timestamp
;
2384 /* No parent. This process exists but we are missing all information about
2385 its creation. The birth time is set to zero but we remember the time of
2390 process
->creation_time
= ltt_time_zero
;
2393 process
->insertion_time
= *timestamp
;
2394 sprintf(buffer
,"%d-%lu.%lu",pid
, process
->creation_time
.tv_sec
,
2395 process
->creation_time
.tv_nsec
);
2396 process
->pid_time
= g_quark_from_string(buffer
);
2398 process
->free_events
= 0;
2399 //process->last_cpu = tfs->cpu_name;
2400 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
2401 process
->execution_stack
= g_array_sized_new(FALSE
, FALSE
,
2402 sizeof(LttvExecutionState
), PREALLOCATED_EXECUTION_STACK
);
2403 process
->execution_stack
= g_array_set_size(process
->execution_stack
, 2);
2404 es
= process
->state
= &g_array_index(process
->execution_stack
,
2405 LttvExecutionState
, 0);
2406 es
->t
= LTTV_STATE_USER_MODE
;
2407 es
->n
= LTTV_STATE_SUBMODE_NONE
;
2408 es
->entry
= *timestamp
;
2409 //g_assert(timestamp->tv_sec != 0);
2410 es
->change
= *timestamp
;
2411 es
->cum_cpu_time
= ltt_time_zero
;
2412 es
->s
= LTTV_STATE_RUN
;
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_FORK
;
2424 /* Allocate an empty function call stack. If it's empty, use 0x0. */
2425 process
->user_stack
= g_array_sized_new(FALSE
, FALSE
,
2426 sizeof(guint64
), 0);
2428 process
->fds
= g_hash_table_new(g_direct_hash
, g_direct_equal
);
2434 lttv_state_find_process(LttvTraceState
*ts
, guint cpu
, guint pid
)
2436 LttvProcessState key
;
2437 LttvProcessState
*process
;
2441 process
= g_hash_table_lookup(ts
->processes
, &key
);
2445 LttvProcessState
*lttv_state_find_process_or_create(LttvTraceState
*ts
,
2446 guint cpu
, guint pid
, const LttTime
*timestamp
)
2448 LttvProcessState
*process
= lttv_state_find_process(ts
, cpu
, pid
);
2449 LttvExecutionState
*es
;
2451 /* Put ltt_time_zero creation time for unexisting processes */
2452 if(unlikely(process
== NULL
)) {
2453 process
= lttv_state_create_process(ts
,
2454 NULL
, cpu
, pid
, 0, LTTV_STATE_UNNAMED
, timestamp
);
2455 /* We are not sure is it's a kernel thread or normal thread, put the
2456 * bottom stack state to unknown */
2457 process
->execution_stack
=
2458 g_array_set_size(process
->execution_stack
, 1);
2459 process
->state
= es
=
2460 &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
2461 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
2462 es
->s
= LTTV_STATE_UNNAMED
;
2467 /* FIXME : this function should be called when we receive an event telling that
2468 * release_task has been called in the kernel. In happens generally when
2469 * the parent waits for its child termination, but may also happens in special
2470 * cases in the child's exit : when the parent ignores its children SIGCCHLD or
2471 * has the flag SA_NOCLDWAIT. It can also happen when the child is part
2472 * of a killed thread group, but isn't the leader.
2474 static int exit_process(LttvTracefileState
*tfs
, LttvProcessState
*process
)
2476 LttvTraceState
*ts
= LTTV_TRACE_STATE(tfs
->parent
.t_context
);
2477 LttvProcessState key
;
2479 /* Wait for both schedule with exit dead and process free to happen.
2480 * They can happen in any order. */
2481 if (++(process
->free_events
) < 2)
2484 key
.pid
= process
->pid
;
2485 key
.cpu
= process
->cpu
;
2486 g_hash_table_remove(ts
->processes
, &key
);
2487 g_array_free(process
->execution_stack
, TRUE
);
2488 g_array_free(process
->user_stack
, TRUE
);
2490 /* the following also clears the content */
2491 g_hash_table_destroy(process
->fds
);
2498 static void free_process_state(gpointer key
, gpointer value
,gpointer user_data
)
2500 g_array_free(((LttvProcessState
*)value
)->execution_stack
, TRUE
);
2501 g_array_free(((LttvProcessState
*)value
)->user_stack
, TRUE
);
2503 /* the following also clears the content */
2504 g_hash_table_destroy(((LttvProcessState
*)value
)->fds
);
2510 static void lttv_state_free_process_table(GHashTable
*processes
)
2512 g_hash_table_foreach(processes
, free_process_state
, NULL
);
2513 g_hash_table_destroy(processes
);
2517 static gboolean
syscall_entry(void *hook_data
, void *call_data
)
2519 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2521 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2522 LttvProcessState
*process
= ts
->running_process
[cpu
];
2523 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2524 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
2525 struct marker_field
*f
= lttv_trace_get_hook_field(th
, 0);
2526 LttvExecutionSubmode submode
;
2527 LttvNameTables
*nt
= ((LttvTraceState
*)(s
->parent
.t_context
))->name_tables
;
2529 guint syscall
= ltt_event_get_unsigned(e
, f
);
2530 expand_syscall_table(ts
, syscall
);
2531 submode
= nt
->syscall_names
[syscall
];
2532 /* There can be no system call from PID 0 : unknown state */
2533 if(process
->pid
!= 0)
2534 push_state(s
, LTTV_STATE_SYSCALL
, submode
);
2539 static gboolean
syscall_exit(void *hook_data
, void *call_data
)
2541 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2543 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2544 LttvProcessState
*process
= ts
->running_process
[cpu
];
2546 /* There can be no system call from PID 0 : unknown state */
2547 if(process
->pid
!= 0)
2548 pop_state(s
, LTTV_STATE_SYSCALL
);
2553 static gboolean
trap_entry(void *hook_data
, void *call_data
)
2555 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2556 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2557 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2558 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
2559 struct marker_field
*f
= lttv_trace_get_hook_field(th
, 0);
2560 LttvNameTables
*nt
= ((LttvTraceState
*)(s
->parent
.t_context
))->name_tables
;
2562 LttvExecutionSubmode submode
;
2564 guint64 trap
= ltt_event_get_long_unsigned(e
, f
);
2566 expand_trap_table(ts
, trap
);
2568 submode
= nt
->trap_names
[trap
];
2570 push_state(s
, LTTV_STATE_TRAP
, submode
);
2572 /* update cpu status */
2573 cpu_push_mode(s
->cpu_state
, LTTV_CPU_TRAP
);
2575 /* update trap status */
2576 g_array_append_val(s
->cpu_state
->trap_stack
, trap
);
2577 ts
->trap_states
[trap
].running
++;
2582 static gboolean
trap_exit(void *hook_data
, void *call_data
)
2584 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2585 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2587 pop_state(s
, LTTV_STATE_TRAP
);
2589 /* update cpu status */
2590 cpu_pop_mode(s
->cpu_state
);
2592 /* update trap status */
2593 if (s
->cpu_state
->trap_stack
->len
> 0) {
2594 gint last
= g_array_index(s
->cpu_state
->trap_stack
, gint
,
2595 s
->cpu_state
->trap_stack
->len
-1);
2596 if(ts
->trap_states
[last
].running
)
2597 ts
->trap_states
[last
].running
--;
2598 g_array_remove_index(s
->cpu_state
->trap_stack
,
2599 s
->cpu_state
->trap_stack
->len
-1);
2604 static gboolean
irq_entry(void *hook_data
, void *call_data
)
2606 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2607 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2608 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2609 //guint8 ev_id = ltt_event_eventtype_id(e);
2610 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
2611 struct marker_field
*f
= lttv_trace_get_hook_field(th
, 0);
2612 LttvNameTables
*nt
= ((LttvTraceState
*)(s
->parent
.t_context
))->name_tables
;
2614 LttvExecutionSubmode submode
;
2615 guint64 irq
= ltt_event_get_long_unsigned(e
, f
);
2617 expand_irq_table(ts
, irq
);
2619 submode
= nt
->irq_names
[irq
];
2621 /* Do something with the info about being in user or system mode when int? */
2622 push_state(s
, LTTV_STATE_IRQ
, submode
);
2624 /* update cpu status */
2625 cpu_push_mode(s
->cpu_state
, LTTV_CPU_IRQ
);
2627 /* update irq status */
2628 g_array_append_val(s
->cpu_state
->irq_stack
, irq
);
2629 irq_push_mode(&ts
->irq_states
[irq
], LTTV_IRQ_BUSY
);
2634 static gboolean
soft_irq_exit(void *hook_data
, void *call_data
)
2636 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2637 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2639 pop_state(s
, LTTV_STATE_SOFT_IRQ
);
2641 /* update cpu status */
2642 cpu_pop_mode(s
->cpu_state
);
2644 /* update softirq status */
2645 if (s
->cpu_state
->softirq_stack
->len
> 0) {
2646 gint last
= g_array_index(s
->cpu_state
->softirq_stack
, gint
, s
->cpu_state
->softirq_stack
->len
-1);
2647 if(ts
->soft_irq_states
[last
].running
)
2648 ts
->soft_irq_states
[last
].running
--;
2649 g_array_remove_index(s
->cpu_state
->softirq_stack
, s
->cpu_state
->softirq_stack
->len
-1);
2654 static gboolean
irq_exit(void *hook_data
, void *call_data
)
2656 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2657 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2659 pop_state(s
, LTTV_STATE_IRQ
);
2661 /* update cpu status */
2662 cpu_pop_mode(s
->cpu_state
);
2664 /* update irq status */
2665 if (s
->cpu_state
->irq_stack
->len
> 0) {
2666 gint last
= g_array_index(s
->cpu_state
->irq_stack
, gint
, s
->cpu_state
->irq_stack
->len
-1);
2667 g_array_remove_index(s
->cpu_state
->irq_stack
, s
->cpu_state
->irq_stack
->len
-1);
2668 irq_pop_mode(&ts
->irq_states
[last
]);
2674 static gboolean
soft_irq_raise(void *hook_data
, void *call_data
)
2676 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2677 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2678 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2679 //guint8 ev_id = ltt_event_eventtype_id(e);
2680 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
2681 struct marker_field
*f
= lttv_trace_get_hook_field(th
, 0);
2682 LttvNameTables
*nt
= ((LttvTraceState
*)(s
->parent
.t_context
))->name_tables
;
2684 LttvExecutionSubmode submode
;
2685 guint64 softirq
= ltt_event_get_long_unsigned(e
, f
);
2686 guint64 nb_softirqs
= nt
->nb_soft_irqs
;
2688 if(softirq
< nb_softirqs
) {
2689 submode
= nt
->soft_irq_names
[softirq
];
2691 /* Fixup an incomplete irq table */
2692 GString
*string
= g_string_new("");
2693 g_string_printf(string
, "softirq %" PRIu64
, softirq
);
2694 submode
= g_quark_from_string(string
->str
);
2695 g_string_free(string
, TRUE
);
2698 /* update softirq status */
2699 /* a soft irq raises are not cumulative */
2700 ts
->soft_irq_states
[softirq
].pending
=1;
2705 static gboolean
soft_irq_entry(void *hook_data
, void *call_data
)
2707 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2708 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2709 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2710 //guint8 ev_id = ltt_event_eventtype_id(e);
2711 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
2712 struct marker_field
*f
= lttv_trace_get_hook_field(th
, 0);
2713 LttvExecutionSubmode submode
;
2714 guint64 softirq
= ltt_event_get_long_unsigned(e
, f
);
2715 expand_soft_irq_table(ts
, softirq
);
2716 LttvNameTables
*nt
= ((LttvTraceState
*)(s
->parent
.t_context
))->name_tables
;
2717 submode
= nt
->soft_irq_names
[softirq
];
2719 /* Do something with the info about being in user or system mode when int? */
2720 push_state(s
, LTTV_STATE_SOFT_IRQ
, submode
);
2722 /* update cpu status */
2723 cpu_push_mode(s
->cpu_state
, LTTV_CPU_SOFT_IRQ
);
2725 /* update softirq status */
2726 g_array_append_val(s
->cpu_state
->softirq_stack
, softirq
);
2727 if(ts
->soft_irq_states
[softirq
].pending
)
2728 ts
->soft_irq_states
[softirq
].pending
--;
2729 ts
->soft_irq_states
[softirq
].running
++;
2734 static gboolean
enum_interrupt(void *hook_data
, void *call_data
)
2736 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2737 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2738 LttvNameTables
*nt
= ts
->name_tables
;
2739 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2740 //guint8 ev_id = ltt_event_eventtype_id(e);
2741 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
2743 GQuark action
= g_quark_from_string(ltt_event_get_string(e
,
2744 lttv_trace_get_hook_field(th
, 0)));
2745 guint irq
= ltt_event_get_long_unsigned(e
, lttv_trace_get_hook_field(th
, 1));
2747 expand_irq_table(ts
, irq
);
2748 nt
->irq_names
[irq
] = action
;
2754 static gboolean
bdev_request_issue(void *hook_data
, void *call_data
)
2756 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2757 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2758 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2759 //guint8 ev_id = ltt_event_eventtype_id(e);
2760 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
2762 guint major
= ltt_event_get_long_unsigned(e
,
2763 lttv_trace_get_hook_field(th
, 0));
2764 guint minor
= ltt_event_get_long_unsigned(e
,
2765 lttv_trace_get_hook_field(th
, 1));
2766 guint oper
= ltt_event_get_long_unsigned(e
,
2767 lttv_trace_get_hook_field(th
, 2));
2768 guint32 devcode
= MKDEV(major
,minor
);
2769 printf("major %d minor %d oper %d devcode %d\n", major
, minor
, oper
, devcode
);
2771 /* have we seen this block device before? */
2772 gpointer bdev
= get_hashed_bdevstate(ts
, devcode
);
2775 bdev_push_mode(bdev
, LTTV_BDEV_BUSY_READING
);
2777 bdev_push_mode(bdev
, LTTV_BDEV_BUSY_WRITING
);
2782 static gboolean
bdev_request_complete(void *hook_data
, void *call_data
)
2784 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2785 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2786 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2787 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
2789 guint major
= ltt_event_get_long_unsigned(e
,
2790 lttv_trace_get_hook_field(th
, 0));
2791 guint minor
= ltt_event_get_long_unsigned(e
,
2792 lttv_trace_get_hook_field(th
, 1));
2793 //guint oper = ltt_event_get_long_unsigned(e,
2794 // lttv_trace_get_hook_field(th, 2));
2795 guint32 devcode
= MKDEV(major
,minor
);
2797 /* have we seen this block device before? */
2798 gpointer bdev
= get_hashed_bdevstate(ts
, devcode
);
2800 /* update block device */
2801 bdev_pop_mode(bdev
);
2806 static void push_function(LttvTracefileState
*tfs
, guint64 funcptr
)
2810 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
2811 guint cpu
= tfs
->cpu
;
2812 LttvProcessState
*process
= ts
->running_process
[cpu
];
2814 guint depth
= process
->user_stack
->len
;
2816 process
->user_stack
=
2817 g_array_set_size(process
->user_stack
, depth
+ 1);
2819 new_func
= &g_array_index(process
->user_stack
, guint64
, depth
);
2820 *new_func
= funcptr
;
2821 process
->current_function
= funcptr
;
2824 static void pop_function(LttvTracefileState
*tfs
, guint64 funcptr
)
2826 guint cpu
= tfs
->cpu
;
2827 LttvTraceState
*ts
= (LttvTraceState
*)tfs
->parent
.t_context
;
2828 LttvProcessState
*process
= ts
->running_process
[cpu
];
2830 if(process
->current_function
!= funcptr
){
2831 g_info("Different functions (%lu.%09lu): ignore it\n",
2832 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
2833 g_info("process state has %" PRIu64
" when pop_function is %" PRIu64
"\n",
2834 process
->current_function
, funcptr
);
2835 g_info("{ %u, %u, %s, %s, %s }\n",
2838 g_quark_to_string(process
->name
),
2839 g_quark_to_string(process
->brand
),
2840 g_quark_to_string(process
->state
->s
));
2843 guint depth
= process
->user_stack
->len
;
2846 g_info("Trying to pop last function on stack (%lu.%09lu): ignore it\n",
2847 tfs
->parent
.timestamp
.tv_sec
, tfs
->parent
.timestamp
.tv_nsec
);
2851 process
->user_stack
=
2852 g_array_set_size(process
->user_stack
, depth
- 1);
2853 process
->current_function
=
2854 g_array_index(process
->user_stack
, guint64
, depth
- 2);
2858 static gboolean
function_entry(void *hook_data
, void *call_data
)
2860 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2861 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2862 //guint8 ev_id = ltt_event_eventtype_id(e);
2863 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
2864 struct marker_field
*f
= lttv_trace_get_hook_field(th
, 0);
2865 guint64 funcptr
= ltt_event_get_long_unsigned(e
, f
);
2867 push_function(s
, funcptr
);
2871 static gboolean
function_exit(void *hook_data
, void *call_data
)
2873 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2874 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2875 //guint8 ev_id = ltt_event_eventtype_id(e);
2876 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
2877 struct marker_field
*f
= lttv_trace_get_hook_field(th
, 0);
2878 guint64 funcptr
= ltt_event_get_long_unsigned(e
, f
);
2880 pop_function(s
, funcptr
);
2884 static gboolean
dump_syscall(void *hook_data
, void *call_data
)
2886 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2887 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2888 LttvNameTables
*nt
= ts
->name_tables
;
2889 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2890 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
2895 id
= ltt_event_get_unsigned(e
, lttv_trace_get_hook_field(th
, 0));
2896 address
= ltt_event_get_long_unsigned(e
, lttv_trace_get_hook_field(th
, 1));
2897 symbol
= ltt_event_get_string(e
, lttv_trace_get_hook_field(th
, 2));
2899 expand_syscall_table(ts
, id
);
2900 nt
->syscall_names
[id
] = g_quark_from_string(symbol
);
2905 static gboolean
dump_kprobe(void *hook_data
, void *call_data
)
2907 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2908 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2909 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2910 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
2914 ip
= ltt_event_get_long_unsigned(e
, lttv_trace_get_hook_field(th
, 0));
2915 symbol
= ltt_event_get_string(e
, lttv_trace_get_hook_field(th
, 1));
2917 expand_kprobe_table(ts
, ip
, symbol
);
2922 static gboolean
dump_softirq(void *hook_data
, void *call_data
)
2924 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2925 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2926 LttvNameTables
*nt
= ts
->name_tables
;
2927 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2928 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
2933 id
= ltt_event_get_unsigned(e
, lttv_trace_get_hook_field(th
, 0));
2934 address
= ltt_event_get_long_unsigned(e
, lttv_trace_get_hook_field(th
, 1));
2935 symbol
= ltt_event_get_string(e
, lttv_trace_get_hook_field(th
, 2));
2937 expand_soft_irq_table(ts
, id
);
2938 nt
->soft_irq_names
[id
] = g_quark_from_string(symbol
);
2943 static gboolean
sched_try_wakeup(void *hook_data
, void *call_data
)
2945 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2946 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2947 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
2948 LttvProcessState
*process
;
2952 woken_pid
= ltt_event_get_int(e
, lttv_trace_get_hook_field(th
, 0));
2953 woken_cpu
= ltt_event_get_unsigned(e
, lttv_trace_get_hook_field(th
, 1));
2955 process
= lttv_state_find_process_or_create(
2956 (LttvTraceState
*)s
->parent
.t_context
,
2957 woken_cpu
, woken_pid
,
2958 &s
->parent
.timestamp
);
2959 process
->state
->s
= LTTV_STATE_WAIT_CPU
;
2960 process
->state
->change
= s
->parent
.timestamp
;
2962 g_debug("Wakeup: process %d on CPU %u\n", woken_pid
, woken_cpu
);
2967 static gboolean
schedchange(void *hook_data
, void *call_data
)
2969 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
2971 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
2972 LttvProcessState
*process
= ts
->running_process
[cpu
];
2973 //LttvProcessState *old_process = ts->running_process[cpu];
2975 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
2976 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
2977 guint pid_in
, pid_out
;
2980 pid_out
= ltt_event_get_unsigned(e
, lttv_trace_get_hook_field(th
, 0));
2981 pid_in
= ltt_event_get_unsigned(e
, lttv_trace_get_hook_field(th
, 1));
2982 state_out
= ltt_event_get_long_int(e
, lttv_trace_get_hook_field(th
, 2));
2984 if(likely(process
!= NULL
)) {
2986 /* We could not know but it was not the idle process executing.
2987 This should only happen at the beginning, before the first schedule
2988 event, and when the initial information (current process for each CPU)
2989 is missing. It is not obvious how we could, after the fact, compensate
2990 the wrongly attributed statistics. */
2992 //This test only makes sense once the state is known and if there is no
2993 //missing events. We need to silently ignore schedchange coming after a
2994 //process_free, or it causes glitches. (FIXME)
2995 //if(unlikely(process->pid != pid_out)) {
2996 // g_assert(process->pid == 0);
2998 if(process
->pid
== 0
2999 && process
->state
->t
== LTTV_STATE_MODE_UNKNOWN
) {
3001 /* Scheduling out of pid 0 at beginning of the trace :
3002 * we know for sure it is in syscall mode at this point. */
3003 g_assert(process
->execution_stack
->len
== 1);
3004 process
->state
->t
= LTTV_STATE_SYSCALL
;
3005 process
->state
->s
= LTTV_STATE_WAIT
;
3006 process
->state
->change
= s
->parent
.timestamp
;
3007 process
->state
->entry
= s
->parent
.timestamp
;
3010 if(unlikely(process
->state
->s
== LTTV_STATE_EXIT
)) {
3011 process
->state
->s
= LTTV_STATE_ZOMBIE
;
3012 process
->state
->change
= s
->parent
.timestamp
;
3014 if(unlikely(state_out
== 0)) process
->state
->s
= LTTV_STATE_WAIT_CPU
;
3015 else process
->state
->s
= LTTV_STATE_WAIT
;
3016 process
->state
->change
= s
->parent
.timestamp
;
3019 if(state_out
== 32 || state_out
== 64) { /* EXIT_DEAD || TASK_DEAD */
3020 /* see sched.h for states */
3021 if (!exit_process(s
, process
)) {
3022 process
->state
->s
= LTTV_STATE_DEAD
;
3023 process
->state
->change
= s
->parent
.timestamp
;
3028 process
= ts
->running_process
[cpu
] = lttv_state_find_process_or_create(
3029 (LttvTraceState
*)s
->parent
.t_context
,
3031 &s
->parent
.timestamp
);
3032 process
->state
->s
= LTTV_STATE_RUN
;
3034 if(process
->usertrace
)
3035 process
->usertrace
->cpu
= cpu
;
3036 // process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)s)->tf);
3037 process
->state
->change
= s
->parent
.timestamp
;
3039 /* update cpu status */
3041 /* going to idle task */
3042 cpu_set_base_mode(s
->cpu_state
, LTTV_CPU_IDLE
);
3044 /* scheduling a real task.
3045 * we must be careful here:
3046 * if we just schedule()'ed to a process that is
3047 * in a trap, we must put the cpu in trap mode
3049 cpu_set_base_mode(s
->cpu_state
, LTTV_CPU_BUSY
);
3050 if(process
->state
->t
== LTTV_STATE_TRAP
)
3051 cpu_push_mode(s
->cpu_state
, LTTV_CPU_TRAP
);
3057 static gboolean
process_fork(void *hook_data
, void *call_data
)
3059 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
3060 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
3061 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
3063 guint child_pid
; /* In the Linux Kernel, there is one PID per thread. */
3064 guint child_tgid
; /* tgid in the Linux kernel is the "real" POSIX PID. */
3065 //LttvProcessState *zombie_process;
3067 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
3068 LttvProcessState
*process
= ts
->running_process
[cpu
];
3069 LttvProcessState
*child_process
;
3070 struct marker_field
*f
;
3073 parent_pid
= ltt_event_get_unsigned(e
, lttv_trace_get_hook_field(th
, 0));
3076 child_pid
= ltt_event_get_unsigned(e
, lttv_trace_get_hook_field(th
, 1));
3077 s
->parent
.target_pid
= child_pid
;
3080 f
= lttv_trace_get_hook_field(th
, 2);
3082 child_tgid
= ltt_event_get_unsigned(e
, f
);
3086 /* Mathieu : it seems like the process might have been scheduled in before the
3087 * fork, and, in a rare case, might be the current process. This might happen
3088 * in a SMP case where we don't have enough precision on the clocks.
3090 * Test reenabled after precision fixes on time. (Mathieu) */
3092 zombie_process
= lttv_state_find_process(ts
, ANY_CPU
, child_pid
);
3094 if(unlikely(zombie_process
!= NULL
)) {
3095 /* Reutilisation of PID. Only now we are sure that the old PID
3096 * has been released. FIXME : should know when release_task happens instead.
3098 guint num_cpus
= ltt_trace_get_num_cpu(ts
->parent
.t
);
3100 for(i
=0; i
< num_cpus
; i
++) {
3101 g_assert(zombie_process
!= ts
->running_process
[i
]);
3104 exit_process(s
, zombie_process
);
3107 g_assert(process
->pid
!= child_pid
);
3108 // FIXME : Add this test in the "known state" section
3109 // g_assert(process->pid == parent_pid);
3110 child_process
= lttv_state_find_process(ts
, ANY_CPU
, child_pid
);
3111 if(child_process
== NULL
) {
3112 child_process
= lttv_state_create_process(ts
, process
, cpu
,
3113 child_pid
, child_tgid
,
3114 LTTV_STATE_UNNAMED
, &s
->parent
.timestamp
);
3116 /* The process has already been created : due to time imprecision between
3117 * multiple CPUs : it has been scheduled in before creation. Note that we
3118 * shouldn't have this kind of imprecision.
3120 * Simply put a correct parent.
3122 g_error("Process %u has been created at [%lu.%09lu] "
3123 "and inserted at [%lu.%09lu] before \n"
3124 "fork on cpu %u[%lu.%09lu].\n"
3125 "Probably an unsynchronized TSC problem on the traced machine.",
3127 child_process
->creation_time
.tv_sec
,
3128 child_process
->creation_time
.tv_nsec
,
3129 child_process
->insertion_time
.tv_sec
,
3130 child_process
->insertion_time
.tv_nsec
,
3131 cpu
, ltt_event_time(e
).tv_sec
, ltt_event_time(e
).tv_nsec
);
3132 //g_assert(0); /* This is a problematic case : the process has been created
3133 // before the fork event */
3134 child_process
->ppid
= process
->pid
;
3135 child_process
->tgid
= child_tgid
;
3137 g_assert(child_process
->name
== LTTV_STATE_UNNAMED
);
3138 child_process
->name
= process
->name
;
3139 child_process
->brand
= process
->brand
;
3144 /* We stamp a newly created process as kernel_thread.
3145 * The thread should not be running yet. */
3146 static gboolean
process_kernel_thread(void *hook_data
, void *call_data
)
3148 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
3149 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
3150 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
3152 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
3153 LttvProcessState
*process
;
3154 LttvExecutionState
*es
;
3157 pid
= (guint
)ltt_event_get_long_unsigned(e
, lttv_trace_get_hook_field(th
, 0));
3158 s
->parent
.target_pid
= pid
;
3160 process
= lttv_state_find_process_or_create(ts
, ANY_CPU
, pid
,
3162 if (process
->state
->s
!= LTTV_STATE_DEAD
) {
3163 process
->execution_stack
=
3164 g_array_set_size(process
->execution_stack
, 1);
3165 es
= process
->state
=
3166 &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
3167 es
->t
= LTTV_STATE_SYSCALL
;
3169 process
->type
= LTTV_STATE_KERNEL_THREAD
;
3174 static gboolean
process_exit(void *hook_data
, void *call_data
)
3176 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
3177 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
3178 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
3180 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
3181 LttvProcessState
*process
; // = ts->running_process[cpu];
3183 pid
= ltt_event_get_unsigned(e
, lttv_trace_get_hook_field(th
, 0));
3184 s
->parent
.target_pid
= pid
;
3186 // FIXME : Add this test in the "known state" section
3187 // g_assert(process->pid == pid);
3189 process
= lttv_state_find_process(ts
, ANY_CPU
, pid
);
3190 if(likely(process
!= NULL
)) {
3191 process
->state
->s
= LTTV_STATE_EXIT
;
3196 static gboolean
process_free(void *hook_data
, void *call_data
)
3198 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
3199 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
3200 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
3201 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
3203 LttvProcessState
*process
;
3205 /* PID of the process to release */
3206 release_pid
= ltt_event_get_unsigned(e
, lttv_trace_get_hook_field(th
, 0));
3207 s
->parent
.target_pid
= release_pid
;
3209 g_assert(release_pid
!= 0);
3211 process
= lttv_state_find_process(ts
, ANY_CPU
, release_pid
);
3212 if(likely(process
!= NULL
))
3213 exit_process(s
, process
);
3216 if(likely(process
!= NULL
)) {
3217 /* release_task is happening at kernel level : we can now safely release
3218 * the data structure of the process */
3219 //This test is fun, though, as it may happen that
3220 //at time t : CPU 0 : process_free
3221 //at time t+150ns : CPU 1 : schedule out
3222 //Clearly due to time imprecision, we disable it. (Mathieu)
3223 //If this weird case happen, we have no choice but to put the
3224 //Currently running process on the cpu to 0.
3225 //I re-enable it following time precision fixes. (Mathieu)
3226 //Well, in the case where an process is freed by a process on another CPU
3227 //and still scheduled, it happens that this is the schedchange that will
3228 //drop the last reference count. Do not free it here!
3229 guint num_cpus
= ltt_trace_get_num_cpu(ts
->parent
.t
);
3231 for(i
=0; i
< num_cpus
; i
++) {
3232 //g_assert(process != ts->running_process[i]);
3233 if(process
== ts
->running_process
[i
]) {
3234 //ts->running_process[i] = lttv_state_find_process(ts, i, 0);
3238 if(i
== num_cpus
) /* process is not scheduled */
3239 exit_process(s
, process
);
3246 static gboolean
process_exec(void *hook_data
, void *call_data
)
3248 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
3249 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
3250 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
3251 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
3254 LttvProcessState
*process
= ts
->running_process
[cpu
];
3256 #if 0//how to use a sequence that must be transformed in a string
3257 /* PID of the process to release */
3258 guint64 name_len
= ltt_event_field_element_number(e
,
3259 lttv_trace_get_hook_field(th
, 0));
3260 //name = ltt_event_get_string(e, lttv_trace_get_hook_field(th, 0));
3261 LttField
*child
= ltt_event_field_element_select(e
,
3262 lttv_trace_get_hook_field(th
, 0), 0);
3264 (gchar
*)(ltt_event_data(e
)+ltt_event_field_offset(e
, child
));
3265 gchar
*null_term_name
= g_new(gchar
, name_len
+1);
3266 memcpy(null_term_name
, name_begin
, name_len
);
3267 null_term_name
[name_len
] = '\0';
3268 process
->name
= g_quark_from_string(null_term_name
);
3271 process
->name
= g_quark_from_string(ltt_event_get_string(e
,
3272 lttv_trace_get_hook_field(th
, 0)));
3273 process
->brand
= LTTV_STATE_UNBRANDED
;
3274 //g_free(null_term_name);
3278 static gboolean
thread_brand(void *hook_data
, void *call_data
)
3280 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
3281 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
3282 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
3283 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
3286 LttvProcessState
*process
= ts
->running_process
[cpu
];
3288 name
= ltt_event_get_string(e
, lttv_trace_get_hook_field(th
, 0));
3289 process
->brand
= g_quark_from_string(name
);
3294 static gboolean
fs_open(void *hook_data
, void *call_data
)
3296 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
3297 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
3298 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
3299 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
3300 struct marker_field
*f
;
3304 LttvProcessState
*process
= ts
->running_process
[cpu
];
3306 f
= lttv_trace_get_hook_field(th
, 0);
3307 fd
= ltt_event_get_int(e
, f
);
3309 f
= lttv_trace_get_hook_field(th
, 1);
3310 filename
= ltt_event_get_string(e
, f
);
3312 g_hash_table_insert(process
->fds
, (gpointer
)(long)fd
,
3313 (gpointer
)(unsigned long)g_quark_from_string(filename
));
3318 static void print_stack(LttvProcessState
*process
)
3320 LttvExecutionState
*es
;
3323 g_debug("Execution stack for process %u %s:\n",
3324 process
->pid
, g_quark_to_string(process
->name
));
3326 for (i
= 0; i
< process
->execution_stack
->len
; i
++) {
3327 es
= &g_array_index(process
->execution_stack
,
3328 LttvExecutionState
, i
);
3329 g_debug("Depth %d mode %s submode %s status %s\n",
3330 i
, g_quark_to_string(es
->t
),
3331 g_quark_to_string(es
->n
),
3332 g_quark_to_string(es
->s
));
3337 static void fix_process(gpointer key
, gpointer value
, gpointer user_data
)
3339 LttvProcessState
*process
;
3340 LttvExecutionState
*es
;
3341 process
= (LttvProcessState
*)value
;
3342 LttTime
*timestamp
= (LttTime
*)user_data
;
3344 print_stack(process
);
3346 if(process
->type
== LTTV_STATE_KERNEL_THREAD
) {
3347 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
3348 if(es
->t
== LTTV_STATE_MODE_UNKNOWN
) {
3349 es
->t
= LTTV_STATE_SYSCALL
;
3350 es
->n
= LTTV_STATE_SUBMODE_NONE
;
3351 es
->entry
= *timestamp
;
3352 es
->change
= *timestamp
;
3353 es
->cum_cpu_time
= ltt_time_zero
;
3354 if(es
->s
== LTTV_STATE_UNNAMED
)
3355 es
->s
= LTTV_STATE_WAIT
;
3358 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
3359 if(es
->t
== LTTV_STATE_MODE_UNKNOWN
) {
3360 es
->t
= LTTV_STATE_USER_MODE
;
3361 es
->n
= LTTV_STATE_SUBMODE_NONE
;
3362 es
->entry
= *timestamp
;
3363 //g_assert(timestamp->tv_sec != 0);
3364 es
->change
= *timestamp
;
3365 es
->cum_cpu_time
= ltt_time_zero
;
3366 if(es
->s
== LTTV_STATE_UNNAMED
)
3367 es
->s
= LTTV_STATE_RUN
;
3369 if(process
->execution_stack
->len
== 1) {
3370 /* Still in bottom unknown mode, means we either:
3371 * - never did a system call
3372 * - are scheduled out from user mode.
3373 * May be either in user mode, syscall mode, running or waiting.*/
3374 /* CHECK : we may be tagging syscall mode when being user mode
3375 * (should be fixed now) */
3376 if (es
->s
== LTTV_STATE_WAIT_CPU
) {
3377 /* nothing to do: scheduled out from userspace */
3379 process
->execution_stack
=
3380 g_array_set_size(process
->execution_stack
, 2);
3381 es
= process
->state
= &g_array_index(process
->execution_stack
,
3382 LttvExecutionState
, 1);
3383 es
->t
= LTTV_STATE_SYSCALL
;
3384 es
->n
= LTTV_STATE_SUBMODE_NONE
;
3385 es
->entry
= *timestamp
;
3386 //g_assert(timestamp->tv_sec != 0);
3387 es
->change
= *timestamp
;
3388 es
->cum_cpu_time
= ltt_time_zero
;
3389 if(es
->s
== LTTV_STATE_WAIT_FORK
)
3390 es
->s
= LTTV_STATE_WAIT
;
3397 static gboolean
statedump_end(void *hook_data
, void *call_data
)
3399 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
3400 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
3401 LttvTracefileContext
*tfc
= (LttvTracefileContext
*)call_data
;
3402 //LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
3403 //LttvTraceHook *th = (LttvTraceHook *)hook_data;
3405 /* For all processes */
3406 /* if kernel thread, if stack[0] is unknown, set to syscall mode, wait */
3407 /* else, if stack[0] is unknown, set to user mode, running */
3409 g_hash_table_foreach(ts
->processes
, fix_process
, &tfc
->timestamp
);
3414 static gboolean
enum_process_state(void *hook_data
, void *call_data
)
3416 LttvTracefileState
*s
= (LttvTracefileState
*)call_data
;
3417 LttEvent
*e
= ltt_tracefile_get_event(s
->parent
.tf
);
3418 //It's slow : optimise later by doing this before reading trace.
3419 LttvTraceHook
*th
= (LttvTraceHook
*)hook_data
;
3425 LttvTraceState
*ts
= (LttvTraceState
*)s
->parent
.t_context
;
3426 LttvProcessState
*process
= ts
->running_process
[cpu
];
3427 LttvProcessState
*parent_process
;
3428 struct marker_field
*f
;
3429 GQuark type
, mode
, submode
, status
;
3430 LttvExecutionState
*es
;
3434 pid
= ltt_event_get_unsigned(e
, lttv_trace_get_hook_field(th
, 0));
3435 s
->parent
.target_pid
= pid
;
3438 parent_pid
= ltt_event_get_unsigned(e
, lttv_trace_get_hook_field(th
, 1));
3441 command
= ltt_event_get_string(e
, lttv_trace_get_hook_field(th
, 2));
3444 f
= lttv_trace_get_hook_field(th
, 3);
3445 type
= ltt_enum_string_get(f
, ltt_event_get_unsigned(e
, f
));
3447 //FIXME: type is rarely used, enum must match possible types.
3450 f
= lttv_trace_get_hook_field(th
, 4);
3451 mode
= ltt_enum_string_get(f
,ltt_event_get_unsigned(e
, f
));
3454 f
= lttv_trace_get_hook_field(th
, 5);
3455 submode
= ltt_enum_string_get(f
, ltt_event_get_unsigned(e
, f
));
3458 f
= lttv_trace_get_hook_field(th
, 6);
3459 status
= ltt_enum_string_get(f
, ltt_event_get_unsigned(e
, f
));
3462 f
= lttv_trace_get_hook_field(th
, 7);
3464 tgid
= ltt_event_get_unsigned(e
, f
);
3469 nb_cpus
= ltt_trace_get_num_cpu(ts
->parent
.t
);
3470 for(i
=0; i
<nb_cpus
; i
++) {
3471 process
= lttv_state_find_process(ts
, i
, pid
);
3472 g_assert(process
!= NULL
);
3474 process
->ppid
= parent_pid
;
3475 process
->tgid
= tgid
;
3476 process
->name
= g_quark_from_string(command
);
3477 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
3478 process
->type
= LTTV_STATE_KERNEL_THREAD
;
3482 /* The process might exist if a process was forked while performing the
3484 process
= lttv_state_find_process(ts
, ANY_CPU
, pid
);
3485 if(process
== NULL
) {
3486 parent_process
= lttv_state_find_process(ts
, ANY_CPU
, parent_pid
);
3487 process
= lttv_state_create_process(ts
, parent_process
, cpu
,
3488 pid
, tgid
, g_quark_from_string(command
),
3489 &s
->parent
.timestamp
);
3491 /* Keep the stack bottom : a running user mode */
3492 /* Disabled because of inconsistencies in the current statedump states. */
3493 if(type
== LTTV_STATE_KERNEL_THREAD
) {
3494 /* Only keep the bottom
3495 * FIXME Kernel thread : can be in syscall or interrupt or trap. */
3496 /* Will cause expected trap when in fact being syscall (even after end of
3498 * Will cause expected interrupt when being syscall. (only before end of
3499 * statedump event) */
3500 // This will cause a "popping last state on stack, ignoring it."
3501 process
->execution_stack
= g_array_set_size(process
->execution_stack
, 1);
3502 es
= process
->state
= &g_array_index(process
->execution_stack
,
3503 LttvExecutionState
, 0);
3504 process
->type
= LTTV_STATE_KERNEL_THREAD
;
3505 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
3506 es
->s
= LTTV_STATE_UNNAMED
;
3507 es
->n
= LTTV_STATE_SUBMODE_UNKNOWN
;
3509 es
->t
= LTTV_STATE_SYSCALL
;
3514 /* User space process :
3515 * bottom : user mode
3516 * either currently running or scheduled out.
3517 * can be scheduled out because interrupted in (user mode or in syscall)
3518 * or because of an explicit call to the scheduler in syscall. Note that
3519 * the scheduler call comes after the irq_exit, so never in interrupt
3521 // temp workaround : set size to 1 : only have user mode bottom of stack.
3522 // will cause g_info message of expected syscall mode when in fact being
3523 // in user mode. Can also cause expected trap when in fact being user
3524 // mode in the event of a page fault reenabling interrupts in the handler.
3525 // Expected syscall and trap can also happen after the end of statedump
3526 // This will cause a "popping last state on stack, ignoring it."
3527 process
->execution_stack
= g_array_set_size(process
->execution_stack
, 1);
3528 es
= process
->state
= &g_array_index(process
->execution_stack
,
3529 LttvExecutionState
, 0);
3530 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
3531 es
->s
= LTTV_STATE_UNNAMED
;
3532 es
->n
= LTTV_STATE_SUBMODE_UNKNOWN
;
3534 es
->t
= LTTV_STATE_USER_MODE
;
3542 es
= process
->state
= &g_array_index(process
->execution_stack
,
3543 LttvExecutionState
, 1);
3544 es
->t
= LTTV_STATE_MODE_UNKNOWN
;
3545 es
->s
= LTTV_STATE_UNNAMED
;
3546 es
->n
= LTTV_STATE_SUBMODE_UNKNOWN
;
3550 /* The process has already been created :
3551 * Probably was forked while dumping the process state or
3552 * was simply scheduled in prior to get the state dump event.
3554 process
->ppid
= parent_pid
;
3555 process
->tgid
= tgid
;
3556 process
->name
= g_quark_from_string(command
);
3557 process
->type
= type
;
3558 es
= &g_array_index(process
->execution_stack
, LttvExecutionState
, 0);
3560 if(es
->t
== LTTV_STATE_MODE_UNKNOWN
) {
3561 if(type
== LTTV_STATE_KERNEL_THREAD
)
3562 es
->t
= LTTV_STATE_SYSCALL
;
3564 es
->t
= LTTV_STATE_USER_MODE
;
3567 /* Don't mess around with the stack, it will eventually become
3568 * ok after the end of state dump. */
3575 gint
lttv_state_hook_add_event_hooks(void *hook_data
, void *call_data
)
3577 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
3579 lttv_state_add_event_hooks(tss
);
3584 void lttv_state_add_event_hooks(LttvTracesetState
*self
)
3586 LttvTraceset
*traceset
= self
->parent
.ts
;
3588 guint i
, j
, k
, nb_trace
, nb_tracefile
;
3592 LttvTracefileState
*tfs
;
3598 LttvAttributeValue val
;
3600 nb_trace
= lttv_traceset_number(traceset
);
3601 for(i
= 0 ; i
< nb_trace
; i
++) {
3602 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
3604 /* Find the eventtype id for the following events and register the
3605 associated by id hooks. */
3607 hooks
= g_array_sized_new(FALSE
, FALSE
, sizeof(LttvTraceHook
), 20);
3608 //hooks = g_array_set_size(hooks, 19); // Max possible number of hooks.
3611 lttv_trace_find_hook(ts
->parent
.t
,
3613 LTT_EVENT_SYSCALL_ENTRY
,
3614 FIELD_ARRAY(LTT_FIELD_SYSCALL_ID
),
3615 syscall_entry
, NULL
, &hooks
);
3617 lttv_trace_find_hook(ts
->parent
.t
,
3619 LTT_EVENT_SYSCALL_EXIT
,
3621 syscall_exit
, NULL
, &hooks
);
3623 lttv_trace_find_hook(ts
->parent
.t
,
3625 LTT_EVENT_TRAP_ENTRY
,
3626 FIELD_ARRAY(LTT_FIELD_TRAP_ID
),
3627 trap_entry
, NULL
, &hooks
);
3629 lttv_trace_find_hook(ts
->parent
.t
,
3631 LTT_EVENT_TRAP_EXIT
,
3633 trap_exit
, NULL
, &hooks
);
3635 lttv_trace_find_hook(ts
->parent
.t
,
3637 LTT_EVENT_PAGE_FAULT_ENTRY
,
3638 FIELD_ARRAY(LTT_FIELD_TRAP_ID
),
3639 trap_entry
, NULL
, &hooks
);
3641 lttv_trace_find_hook(ts
->parent
.t
,
3643 LTT_EVENT_PAGE_FAULT_EXIT
,
3645 trap_exit
, NULL
, &hooks
);
3647 lttv_trace_find_hook(ts
->parent
.t
,
3649 LTT_EVENT_PAGE_FAULT_NOSEM_ENTRY
,
3650 FIELD_ARRAY(LTT_FIELD_TRAP_ID
),
3651 trap_entry
, NULL
, &hooks
);
3653 lttv_trace_find_hook(ts
->parent
.t
,
3655 LTT_EVENT_PAGE_FAULT_NOSEM_EXIT
,
3657 trap_exit
, NULL
, &hooks
);
3659 lttv_trace_find_hook(ts
->parent
.t
,
3661 LTT_EVENT_IRQ_ENTRY
,
3662 FIELD_ARRAY(LTT_FIELD_IRQ_ID
),
3663 irq_entry
, NULL
, &hooks
);
3665 lttv_trace_find_hook(ts
->parent
.t
,
3669 irq_exit
, NULL
, &hooks
);
3671 lttv_trace_find_hook(ts
->parent
.t
,
3673 LTT_EVENT_SOFT_IRQ_RAISE
,
3674 FIELD_ARRAY(LTT_FIELD_SOFT_IRQ_ID
),
3675 soft_irq_raise
, NULL
, &hooks
);
3677 lttv_trace_find_hook(ts
->parent
.t
,
3679 LTT_EVENT_SOFT_IRQ_ENTRY
,
3680 FIELD_ARRAY(LTT_FIELD_SOFT_IRQ_ID
),
3681 soft_irq_entry
, NULL
, &hooks
);
3683 lttv_trace_find_hook(ts
->parent
.t
,
3685 LTT_EVENT_SOFT_IRQ_EXIT
,
3687 soft_irq_exit
, NULL
, &hooks
);
3689 lttv_trace_find_hook(ts
->parent
.t
,
3691 LTT_EVENT_SCHED_SCHEDULE
,
3692 FIELD_ARRAY(LTT_FIELD_PREV_PID
, LTT_FIELD_NEXT_PID
,
3693 LTT_FIELD_PREV_STATE
),
3694 schedchange
, NULL
, &hooks
);
3696 lttv_trace_find_hook(ts
->parent
.t
,
3698 LTT_EVENT_SCHED_TRY_WAKEUP
,
3699 FIELD_ARRAY(LTT_FIELD_PID
, LTT_FIELD_CPU_ID
, LTT_FIELD_STATE
),
3700 sched_try_wakeup
, NULL
, &hooks
);
3702 lttv_trace_find_hook(ts
->parent
.t
,
3704 LTT_EVENT_PROCESS_FORK
,
3705 FIELD_ARRAY(LTT_FIELD_PARENT_PID
, LTT_FIELD_CHILD_PID
,
3706 LTT_FIELD_CHILD_TGID
),
3707 process_fork
, NULL
, &hooks
);
3709 lttv_trace_find_hook(ts
->parent
.t
,
3711 LTT_EVENT_KTHREAD_CREATE
,
3712 FIELD_ARRAY(LTT_FIELD_PID
),
3713 process_kernel_thread
, NULL
, &hooks
);
3715 lttv_trace_find_hook(ts
->parent
.t
,
3717 LTT_EVENT_PROCESS_EXIT
,
3718 FIELD_ARRAY(LTT_FIELD_PID
),
3719 process_exit
, NULL
, &hooks
);
3721 lttv_trace_find_hook(ts
->parent
.t
,
3723 LTT_EVENT_PROCESS_FREE
,
3724 FIELD_ARRAY(LTT_FIELD_PID
),
3725 process_free
, NULL
, &hooks
);
3727 lttv_trace_find_hook(ts
->parent
.t
,
3730 FIELD_ARRAY(LTT_FIELD_FILENAME
),
3731 process_exec
, NULL
, &hooks
);
3733 lttv_trace_find_hook(ts
->parent
.t
,
3734 LTT_CHANNEL_USERSPACE
,
3735 LTT_EVENT_THREAD_BRAND
,
3736 FIELD_ARRAY(LTT_FIELD_NAME
),
3737 thread_brand
, NULL
, &hooks
);
3739 /* statedump-related hooks */
3740 lttv_trace_find_hook(ts
->parent
.t
,
3741 LTT_CHANNEL_TASK_STATE
,
3742 LTT_EVENT_PROCESS_STATE
,
3743 FIELD_ARRAY(LTT_FIELD_PID
, LTT_FIELD_PARENT_PID
, LTT_FIELD_NAME
,
3744 LTT_FIELD_TYPE
, LTT_FIELD_MODE
, LTT_FIELD_SUBMODE
,
3745 LTT_FIELD_STATUS
, LTT_FIELD_TGID
),
3746 enum_process_state
, NULL
, &hooks
);
3748 lttv_trace_find_hook(ts
->parent
.t
,
3749 LTT_CHANNEL_GLOBAL_STATE
,
3750 LTT_EVENT_STATEDUMP_END
,
3752 statedump_end
, NULL
, &hooks
);
3754 lttv_trace_find_hook(ts
->parent
.t
,
3755 LTT_CHANNEL_IRQ_STATE
,
3756 LTT_EVENT_LIST_INTERRUPT
,
3757 FIELD_ARRAY(LTT_FIELD_ACTION
, LTT_FIELD_IRQ_ID
),
3758 enum_interrupt
, NULL
, &hooks
);
3760 lttv_trace_find_hook(ts
->parent
.t
,
3762 LTT_EVENT_REQUEST_ISSUE
,
3763 FIELD_ARRAY(LTT_FIELD_MAJOR
, LTT_FIELD_MINOR
, LTT_FIELD_OPERATION
),
3764 bdev_request_issue
, NULL
, &hooks
);
3766 lttv_trace_find_hook(ts
->parent
.t
,
3768 LTT_EVENT_REQUEST_COMPLETE
,
3769 FIELD_ARRAY(LTT_FIELD_MAJOR
, LTT_FIELD_MINOR
, LTT_FIELD_OPERATION
),
3770 bdev_request_complete
, NULL
, &hooks
);
3772 lttv_trace_find_hook(ts
->parent
.t
,
3773 LTT_CHANNEL_USERSPACE
,
3774 LTT_EVENT_FUNCTION_ENTRY
,
3775 FIELD_ARRAY(LTT_FIELD_THIS_FN
, LTT_FIELD_CALL_SITE
),
3776 function_entry
, NULL
, &hooks
);
3778 lttv_trace_find_hook(ts
->parent
.t
,
3779 LTT_CHANNEL_USERSPACE
,
3780 LTT_EVENT_FUNCTION_EXIT
,
3781 FIELD_ARRAY(LTT_FIELD_THIS_FN
, LTT_FIELD_CALL_SITE
),
3782 function_exit
, NULL
, &hooks
);
3784 lttv_trace_find_hook(ts
->parent
.t
,
3785 LTT_CHANNEL_SYSCALL_STATE
,
3786 LTT_EVENT_SYS_CALL_TABLE
,
3787 FIELD_ARRAY(LTT_FIELD_ID
, LTT_FIELD_ADDRESS
, LTT_FIELD_SYMBOL
),
3788 dump_syscall
, NULL
, &hooks
);
3790 lttv_trace_find_hook(ts
->parent
.t
,
3791 LTT_CHANNEL_KPROBE_STATE
,
3792 LTT_EVENT_KPROBE_TABLE
,
3793 FIELD_ARRAY(LTT_FIELD_IP
, LTT_FIELD_SYMBOL
),
3794 dump_kprobe
, NULL
, &hooks
);
3796 lttv_trace_find_hook(ts
->parent
.t
,
3797 LTT_CHANNEL_SOFTIRQ_STATE
,
3798 LTT_EVENT_SOFTIRQ_VEC
,
3799 FIELD_ARRAY(LTT_FIELD_ID
, LTT_FIELD_ADDRESS
, LTT_FIELD_SYMBOL
),
3800 dump_softirq
, NULL
, &hooks
);
3802 lttv_trace_find_hook(ts
->parent
.t
,
3805 FIELD_ARRAY(LTT_FIELD_FD
, LTT_FIELD_FILENAME
),
3806 fs_open
, NULL
, &hooks
);
3808 /* Add these hooks to each event_by_id hooks list */
3810 nb_tracefile
= ts
->parent
.tracefiles
->len
;
3812 for(j
= 0 ; j
< nb_tracefile
; j
++) {
3814 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
3815 LttvTracefileContext
*, j
));
3817 for(k
= 0 ; k
< hooks
->len
; k
++) {
3818 th
= &g_array_index(hooks
, LttvTraceHook
, k
);
3819 if (th
->mdata
== tfs
->parent
.tf
->mdata
)
3821 lttv_hooks_by_id_find(tfs
->parent
.event_by_id
, th
->id
),
3827 lttv_attribute_find(ts
->parent
.a
, LTTV_STATE_HOOKS
, LTTV_POINTER
, &val
);
3828 *(val
.v_pointer
) = hooks
;
3832 gint
lttv_state_hook_remove_event_hooks(void *hook_data
, void *call_data
)
3834 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
3836 lttv_state_remove_event_hooks(tss
);
3841 void lttv_state_remove_event_hooks(LttvTracesetState
*self
)
3843 LttvTraceset
*traceset
= self
->parent
.ts
;
3845 guint i
, j
, k
, nb_trace
, nb_tracefile
;
3849 LttvTracefileState
*tfs
;
3855 LttvAttributeValue val
;
3857 nb_trace
= lttv_traceset_number(traceset
);
3858 for(i
= 0 ; i
< nb_trace
; i
++) {
3859 ts
= LTTV_TRACE_STATE(self
->parent
.traces
[i
]);
3861 lttv_attribute_find(ts
->parent
.a
, LTTV_STATE_HOOKS
, LTTV_POINTER
, &val
);
3862 hooks
= *(val
.v_pointer
);
3864 /* Remove these hooks from each event_by_id hooks list */
3866 nb_tracefile
= ts
->parent
.tracefiles
->len
;
3868 for(j
= 0 ; j
< nb_tracefile
; j
++) {
3870 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
3871 LttvTracefileContext
*, j
));
3873 for(k
= 0 ; k
< hooks
->len
; k
++) {
3874 th
= &g_array_index(hooks
, LttvTraceHook
, k
);
3875 if (th
->mdata
== tfs
->parent
.tf
->mdata
)
3876 lttv_hooks_remove_data(
3877 lttv_hooks_by_id_find(tfs
->parent
.event_by_id
, th
->id
),
3882 lttv_trace_hook_remove_all(&hooks
);
3883 g_array_free(hooks
, TRUE
);
3887 static gboolean
state_save_event_hook(void *hook_data
, void *call_data
)
3889 guint
*event_count
= (guint
*)hook_data
;
3891 /* Only save at LTTV_STATE_SAVE_INTERVAL */
3892 if(likely((*event_count
)++ < LTTV_STATE_SAVE_INTERVAL
))
3897 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
3899 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
3901 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
3903 LttvAttributeValue value
;
3905 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
3906 LTTV_STATE_SAVED_STATES
);
3907 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
3908 value
= lttv_attribute_add(saved_states_tree
,
3909 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
3910 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
3911 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
3912 *(value
.v_time
) = self
->parent
.timestamp
;
3913 lttv_state_save(tcs
, saved_state_tree
);
3914 g_debug("Saving state at time %lu.%lu", self
->parent
.timestamp
.tv_sec
,
3915 self
->parent
.timestamp
.tv_nsec
);
3917 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
3922 static gboolean
state_save_after_trace_hook(void *hook_data
, void *call_data
)
3924 LttvTraceState
*tcs
= (LttvTraceState
*)(call_data
);
3926 *(tcs
->max_time_state_recomputed_in_seek
) = tcs
->parent
.time_span
.end_time
;
3931 guint
lttv_state_current_cpu(LttvTracefileState
*tfs
)
3939 static gboolean
block_start(void *hook_data
, void *call_data
)
3941 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
3943 LttvTracefileState
*tfcs
;
3945 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
3947 LttEventPosition
*ep
;
3949 guint i
, nb_block
, nb_event
, nb_tracefile
;
3953 LttvAttribute
*saved_states_tree
, *saved_state_tree
;
3955 LttvAttributeValue value
;
3957 ep
= ltt_event_position_new();
3959 nb_tracefile
= tcs
->parent
.tracefiles
->len
;
3961 /* Count the number of events added since the last block end in any
3964 for(i
= 0 ; i
< nb_tracefile
; i
++) {
3966 LTTV_TRACEFILE_STATE(&g_array_index(tcs
->parent
.tracefiles
,
3967 LttvTracefileContext
, i
));
3968 ltt_event_position(tfcs
->parent
.e
, ep
);
3969 ltt_event_position_get(ep
, &nb_block
, &nb_event
, &tf
);
3970 tcs
->nb_event
+= nb_event
- tfcs
->saved_position
;
3971 tfcs
->saved_position
= nb_event
;
3975 if(tcs
->nb_event
>= tcs
->save_interval
) {
3976 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
3977 LTTV_STATE_SAVED_STATES
);
3978 saved_state_tree
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
3979 value
= lttv_attribute_add(saved_states_tree
,
3980 lttv_attribute_get_number(saved_states_tree
), LTTV_GOBJECT
);
3981 *(value
.v_gobject
) = (GObject
*)saved_state_tree
;
3982 value
= lttv_attribute_add(saved_state_tree
, LTTV_STATE_TIME
, LTTV_TIME
);
3983 *(value
.v_time
) = self
->parent
.timestamp
;
3984 lttv_state_save(tcs
, saved_state_tree
);
3986 g_debug("Saving state at time %lu.%lu", self
->parent
.timestamp
.tv_sec
,
3987 self
->parent
.timestamp
.tv_nsec
);
3989 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
3995 static gboolean
block_end(void *hook_data
, void *call_data
)
3997 LttvTracefileState
*self
= (LttvTracefileState
*)call_data
;
3999 LttvTraceState
*tcs
= (LttvTraceState
*)(self
->parent
.t_context
);
4003 LttEventPosition
*ep
;
4005 guint nb_block
, nb_event
;
4007 ep
= ltt_event_position_new();
4008 ltt_event_position(self
->parent
.e
, ep
);
4009 ltt_event_position_get(ep
, &nb_block
, &nb_event
, &tf
);
4010 tcs
->nb_event
+= nb_event
- self
->saved_position
+ 1;
4011 self
->saved_position
= 0;
4012 *(tcs
->max_time_state_recomputed_in_seek
) = self
->parent
.timestamp
;
4019 void lttv_state_save_add_event_hooks(LttvTracesetState
*self
)
4021 LttvTraceset
*traceset
= self
->parent
.ts
;
4023 guint i
, j
, nb_trace
, nb_tracefile
;
4027 LttvTracefileState
*tfs
;
4029 LttvTraceHook hook_start
, hook_end
;
4031 nb_trace
= lttv_traceset_number(traceset
);
4032 for(i
= 0 ; i
< nb_trace
; i
++) {
4033 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
4035 lttv_trace_find_hook(ts
->parent
.t
, "core","block_start",NULL
,
4036 NULL
, NULL
, block_start
, &hook_start
);
4037 lttv_trace_find_hook(ts
->parent
.t
, "core","block_end",NULL
,
4038 NULL
, NULL
, block_end
, &hook_end
);
4040 nb_tracefile
= ts
->parent
.tracefiles
->len
;
4042 for(j
= 0 ; j
< nb_tracefile
; j
++) {
4044 LTTV_TRACEFILE_STATE(&g_array_index(ts
->parent
.tracefiles
,
4045 LttvTracefileContext
, j
));
4046 lttv_hooks_add(lttv_hooks_by_id_find(tfs
->parent
.event_by_id
,
4047 hook_start
.id
), hook_start
.h
, NULL
, LTTV_PRIO_STATE
);
4048 lttv_hooks_add(lttv_hooks_by_id_find(tfs
->parent
.event_by_id
,
4049 hook_end
.id
), hook_end
.h
, NULL
, LTTV_PRIO_STATE
);
4055 void lttv_state_save_add_event_hooks(LttvTracesetState
*self
)
4057 LttvTraceset
*traceset
= self
->parent
.ts
;
4059 guint i
, j
, nb_trace
, nb_tracefile
;
4063 LttvTracefileState
*tfs
;
4066 nb_trace
= lttv_traceset_number(traceset
);
4067 for(i
= 0 ; i
< nb_trace
; i
++) {
4069 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
4070 nb_tracefile
= ts
->parent
.tracefiles
->len
;
4072 if(ts
->has_precomputed_states
) continue;
4074 guint
*event_count
= g_new(guint
, 1);
4077 for(j
= 0 ; j
< nb_tracefile
; j
++) {
4079 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
4080 LttvTracefileContext
*, j
));
4081 lttv_hooks_add(tfs
->parent
.event
,
4082 state_save_event_hook
,
4089 lttv_process_traceset_begin(&self
->parent
,
4090 NULL
, NULL
, NULL
, NULL
, NULL
);
4094 gint
lttv_state_save_hook_add_event_hooks(void *hook_data
, void *call_data
)
4096 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
4098 lttv_state_save_add_event_hooks(tss
);
4105 void lttv_state_save_remove_event_hooks(LttvTracesetState
*self
)
4107 LttvTraceset
*traceset
= self
->parent
.ts
;
4109 guint i
, j
, nb_trace
, nb_tracefile
;
4113 LttvTracefileState
*tfs
;
4115 LttvTraceHook hook_start
, hook_end
;
4117 nb_trace
= lttv_traceset_number(traceset
);
4118 for(i
= 0 ; i
< nb_trace
; i
++) {
4119 ts
= LTTV_TRACE_STATE(self
->parent
.traces
[i
]);
4121 lttv_trace_find_hook(ts
->parent
.t
, "core","block_start",NULL
,
4122 NULL
, NULL
, block_start
, &hook_start
);
4124 lttv_trace_find_hook(ts
->parent
.t
, "core","block_end",NULL
,
4125 NULL
, NULL
, block_end
, &hook_end
);
4127 nb_tracefile
= ts
->parent
.tracefiles
->len
;
4129 for(j
= 0 ; j
< nb_tracefile
; j
++) {
4131 LTTV_TRACEFILE_STATE(&g_array_index(ts
->parent
.tracefiles
,
4132 LttvTracefileContext
, j
));
4133 lttv_hooks_remove_data(lttv_hooks_by_id_find(
4134 tfs
->parent
.event_by_id
, hook_start
.id
), hook_start
.h
, NULL
);
4135 lttv_hooks_remove_data(lttv_hooks_by_id_find(
4136 tfs
->parent
.event_by_id
, hook_end
.id
), hook_end
.h
, NULL
);
4142 void lttv_state_save_remove_event_hooks(LttvTracesetState
*self
)
4144 LttvTraceset
*traceset
= self
->parent
.ts
;
4146 guint i
, j
, nb_trace
, nb_tracefile
;
4150 LttvTracefileState
*tfs
;
4152 LttvHooks
*after_trace
= lttv_hooks_new();
4154 lttv_hooks_add(after_trace
,
4155 state_save_after_trace_hook
,
4160 lttv_process_traceset_end(&self
->parent
,
4161 NULL
, after_trace
, NULL
, NULL
, NULL
);
4163 lttv_hooks_destroy(after_trace
);
4165 nb_trace
= lttv_traceset_number(traceset
);
4166 for(i
= 0 ; i
< nb_trace
; i
++) {
4168 ts
= (LttvTraceState
*)self
->parent
.traces
[i
];
4169 nb_tracefile
= ts
->parent
.tracefiles
->len
;
4171 if(ts
->has_precomputed_states
) continue;
4173 guint
*event_count
= NULL
;
4175 for(j
= 0 ; j
< nb_tracefile
; j
++) {
4177 LTTV_TRACEFILE_STATE(g_array_index(ts
->parent
.tracefiles
,
4178 LttvTracefileContext
*, j
));
4179 event_count
= lttv_hooks_remove(tfs
->parent
.event
,
4180 state_save_event_hook
);
4182 if(event_count
) g_free(event_count
);
4186 gint
lttv_state_save_hook_remove_event_hooks(void *hook_data
, void *call_data
)
4188 LttvTracesetState
*tss
= (LttvTracesetState
*)(call_data
);
4190 lttv_state_save_remove_event_hooks(tss
);
4195 void lttv_state_traceset_seek_time_closest(LttvTracesetState
*self
, LttTime t
)
4197 LttvTraceset
*traceset
= self
->parent
.ts
;
4201 int min_pos
, mid_pos
, max_pos
;
4203 guint call_rest
= 0;
4205 LttvTraceState
*tcs
;
4207 LttvAttributeValue value
;
4209 LttvAttributeType type
;
4211 LttvAttributeName name
;
4215 LttvAttribute
*saved_states_tree
, *saved_state_tree
, *closest_tree
= NULL
;
4217 //g_tree_destroy(self->parent.pqueue);
4218 //self->parent.pqueue = g_tree_new(compare_tracefile);
4220 g_info("Entering seek_time_closest for time %lu.%lu", t
.tv_sec
, t
.tv_nsec
);
4222 nb_trace
= lttv_traceset_number(traceset
);
4223 for(i
= 0 ; i
< nb_trace
; i
++) {
4224 tcs
= (LttvTraceState
*)self
->parent
.traces
[i
];
4226 if(ltt_time_compare(t
, *(tcs
->max_time_state_recomputed_in_seek
)) < 0) {
4227 saved_states_tree
= lttv_attribute_find_subdir(tcs
->parent
.t_a
,
4228 LTTV_STATE_SAVED_STATES
);
4231 if(saved_states_tree
) {
4232 max_pos
= lttv_attribute_get_number(saved_states_tree
) - 1;
4233 mid_pos
= max_pos
/ 2;
4234 while(min_pos
< max_pos
) {
4235 type
= lttv_attribute_get(saved_states_tree
, mid_pos
,
4236 &name
, &value
, &is_named
);
4237 g_assert(type
== LTTV_GOBJECT
);
4238 saved_state_tree
= *((LttvAttribute
**)(value
.v_gobject
));
4239 type
= lttv_attribute_get_by_name(saved_state_tree
,
4240 LTTV_STATE_TIME
, &value
);
4241 g_assert(type
== LTTV_TIME
);
4242 if(ltt_time_compare(*(value
.v_time
), t
) < 0) {
4244 closest_tree
= saved_state_tree
;
4246 else max_pos
= mid_pos
- 1;
4248 mid_pos
= (min_pos
+ max_pos
+ 1) / 2;
4252 /* restore the closest earlier saved state */
4254 lttv_state_restore(tcs
, closest_tree
);
4258 /* There is no saved state, yet we want to have it. Restart at T0 */
4260 restore_init_state(tcs
);
4261 lttv_process_trace_seek_time(&(tcs
->parent
), ltt_time_zero
);
4264 /* We want to seek quickly without restoring/updating the state */
4266 restore_init_state(tcs
);
4267 lttv_process_trace_seek_time(&(tcs
->parent
), t
);
4270 if(!call_rest
) g_info("NOT Calling restore");
4274 static void traceset_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
4279 static void traceset_state_finalize (LttvTracesetState
*self
)
4281 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE
))->
4282 finalize(G_OBJECT(self
));
4286 static void traceset_state_class_init (LttvTracesetContextClass
*klass
)
4288 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
4290 gobject_class
->finalize
= (void (*)(GObject
*self
)) traceset_state_finalize
;
4291 klass
->init
= (void (*)(LttvTracesetContext
*self
, LttvTraceset
*ts
))init
;
4292 klass
->fini
= (void (*)(LttvTracesetContext
*self
))fini
;
4293 klass
->new_traceset_context
= new_traceset_context
;
4294 klass
->new_trace_context
= new_trace_context
;
4295 klass
->new_tracefile_context
= new_tracefile_context
;
4299 GType
lttv_traceset_state_get_type(void)
4301 static GType type
= 0;
4303 static const GTypeInfo info
= {
4304 sizeof (LttvTracesetStateClass
),
4305 NULL
, /* base_init */
4306 NULL
, /* base_finalize */
4307 (GClassInitFunc
) traceset_state_class_init
, /* class_init */
4308 NULL
, /* class_finalize */
4309 NULL
, /* class_data */
4310 sizeof (LttvTracesetState
),
4311 0, /* n_preallocs */
4312 (GInstanceInitFunc
) traceset_state_instance_init
, /* instance_init */
4313 NULL
/* value handling */
4316 type
= g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE
, "LttvTracesetStateType",
4323 static void trace_state_instance_init (GTypeInstance
*instance
, gpointer g_class
)
4328 static void trace_state_finalize (LttvTraceState
*self
)
4330 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_CONTEXT_TYPE
))->
4331 finalize(G_OBJECT(self
));
4335 static void trace_state_class_init (LttvTraceStateClass
*klass
)
4337 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
4339 gobject_class
->finalize
= (void (*)(GObject
*self
)) trace_state_finalize
;
4340 klass
->state_save
= state_save
;
4341 klass
->state_restore
= state_restore
;
4342 klass
->state_saved_free
= state_saved_free
;
4346 GType
lttv_trace_state_get_type(void)
4348 static GType type
= 0;
4350 static const GTypeInfo info
= {
4351 sizeof (LttvTraceStateClass
),
4352 NULL
, /* base_init */
4353 NULL
, /* base_finalize */
4354 (GClassInitFunc
) trace_state_class_init
, /* class_init */
4355 NULL
, /* class_finalize */
4356 NULL
, /* class_data */
4357 sizeof (LttvTraceState
),
4358 0, /* n_preallocs */
4359 (GInstanceInitFunc
) trace_state_instance_init
, /* instance_init */
4360 NULL
/* value handling */
4363 type
= g_type_register_static (LTTV_TRACE_CONTEXT_TYPE
,
4364 "LttvTraceStateType", &info
, 0);
4370 static void tracefile_state_instance_init (GTypeInstance
*instance
,
4376 static void tracefile_state_finalize (LttvTracefileState
*self
)
4378 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_CONTEXT_TYPE
))->
4379 finalize(G_OBJECT(self
));
4383 static void tracefile_state_class_init (LttvTracefileStateClass
*klass
)
4385 GObjectClass
*gobject_class
= G_OBJECT_CLASS(klass
);
4387 gobject_class
->finalize
= (void (*)(GObject
*self
)) tracefile_state_finalize
;
4391 GType
lttv_tracefile_state_get_type(void)
4393 static GType type
= 0;
4395 static const GTypeInfo info
= {
4396 sizeof (LttvTracefileStateClass
),
4397 NULL
, /* base_init */
4398 NULL
, /* base_finalize */
4399 (GClassInitFunc
) tracefile_state_class_init
, /* class_init */
4400 NULL
, /* class_finalize */
4401 NULL
, /* class_data */
4402 sizeof (LttvTracefileState
),
4403 0, /* n_preallocs */
4404 (GInstanceInitFunc
) tracefile_state_instance_init
, /* instance_init */
4405 NULL
/* value handling */
4408 type
= g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE
,
4409 "LttvTracefileStateType", &info
, 0);
4415 static void module_init()
4417 LTTV_STATE_UNNAMED
= g_quark_from_string("");
4418 LTTV_STATE_UNBRANDED
= g_quark_from_string("");
4419 LTTV_STATE_MODE_UNKNOWN
= g_quark_from_string("MODE_UNKNOWN");
4420 LTTV_STATE_USER_MODE
= g_quark_from_string("USER_MODE");
4421 LTTV_STATE_SYSCALL
= g_quark_from_string("SYSCALL");
4422 LTTV_STATE_TRAP
= g_quark_from_string("TRAP");
4423 LTTV_STATE_IRQ
= g_quark_from_string("IRQ");
4424 LTTV_STATE_SOFT_IRQ
= g_quark_from_string("SOFTIRQ");
4425 LTTV_STATE_SUBMODE_UNKNOWN
= g_quark_from_string("UNKNOWN");
4426 LTTV_STATE_SUBMODE_NONE
= g_quark_from_string("NONE");
4427 LTTV_STATE_WAIT_FORK
= g_quark_from_string("WAIT_FORK");
4428 LTTV_STATE_WAIT_CPU
= g_quark_from_string("WAIT_CPU");
4429 LTTV_STATE_EXIT
= g_quark_from_string("EXIT");
4430 LTTV_STATE_ZOMBIE
= g_quark_from_string("ZOMBIE");
4431 LTTV_STATE_WAIT
= g_quark_from_string("WAIT");
4432 LTTV_STATE_RUN
= g_quark_from_string("RUN");
4433 LTTV_STATE_DEAD
= g_quark_from_string("DEAD");
4434 LTTV_STATE_USER_THREAD
= g_quark_from_string("USER_THREAD");
4435 LTTV_STATE_KERNEL_THREAD
= g_quark_from_string("KERNEL_THREAD");
4436 LTTV_STATE_TRACEFILES
= g_quark_from_string("tracefiles");
4437 LTTV_STATE_PROCESSES
= g_quark_from_string("processes");
4438 LTTV_STATE_PROCESS
= g_quark_from_string("process");
4439 LTTV_STATE_RUNNING_PROCESS
= g_quark_from_string("running_process");
4440 LTTV_STATE_EVENT
= g_quark_from_string("event");
4441 LTTV_STATE_SAVED_STATES
= g_quark_from_string("saved states");
4442 LTTV_STATE_SAVED_STATES_TIME
= g_quark_from_string("saved states time");
4443 LTTV_STATE_TIME
= g_quark_from_string("time");
4444 LTTV_STATE_HOOKS
= g_quark_from_string("saved state hooks");
4445 LTTV_STATE_NAME_TABLES
= g_quark_from_string("name tables");
4446 LTTV_STATE_TRACE_STATE_USE_COUNT
=
4447 g_quark_from_string("trace_state_use_count");
4448 LTTV_STATE_RESOURCE_CPUS
= g_quark_from_string("cpu resource states");
4449 LTTV_STATE_RESOURCE_CPUS
= g_quark_from_string("cpu count");
4450 LTTV_STATE_RESOURCE_IRQS
= g_quark_from_string("irq resource states");
4451 LTTV_STATE_RESOURCE_SOFT_IRQS
= g_quark_from_string("soft irq resource states");
4452 LTTV_STATE_RESOURCE_TRAPS
= g_quark_from_string("trap resource states");
4453 LTTV_STATE_RESOURCE_BLKDEVS
= g_quark_from_string("blkdevs resource states");
4455 LTT_CHANNEL_FD_STATE
= g_quark_from_string("fd_state");
4456 LTT_CHANNEL_GLOBAL_STATE
= g_quark_from_string("global_state");
4457 LTT_CHANNEL_IRQ_STATE
= g_quark_from_string("irq_state");
4458 LTT_CHANNEL_MODULE_STATE
= g_quark_from_string("module_state");
4459 LTT_CHANNEL_NETIF_STATE
= g_quark_from_string("netif_state");
4460 LTT_CHANNEL_SOFTIRQ_STATE
= g_quark_from_string("softirq_state");
4461 LTT_CHANNEL_SWAP_STATE
= g_quark_from_string("swap_state");
4462 LTT_CHANNEL_SYSCALL_STATE
= g_quark_from_string("syscall_state");
4463 LTT_CHANNEL_TASK_STATE
= g_quark_from_string("task_state");
4464 LTT_CHANNEL_VM_STATE
= g_quark_from_string("vm_state");
4465 LTT_CHANNEL_KPROBE_STATE
= g_quark_from_string("kprobe_state");
4466 LTT_CHANNEL_FS
= g_quark_from_string("fs");
4467 LTT_CHANNEL_KERNEL
= g_quark_from_string("kernel");
4468 LTT_CHANNEL_MM
= g_quark_from_string("mm");
4469 LTT_CHANNEL_USERSPACE
= g_quark_from_string("userspace");
4470 LTT_CHANNEL_BLOCK
= g_quark_from_string("block");
4472 LTT_EVENT_SYSCALL_ENTRY
= g_quark_from_string("syscall_entry");
4473 LTT_EVENT_SYSCALL_EXIT
= g_quark_from_string("syscall_exit");
4474 LTT_EVENT_TRAP_ENTRY
= g_quark_from_string("trap_entry");
4475 LTT_EVENT_TRAP_EXIT
= g_quark_from_string("trap_exit");
4476 LTT_EVENT_PAGE_FAULT_ENTRY
= g_quark_from_string("page_fault_entry");
4477 LTT_EVENT_PAGE_FAULT_EXIT
= g_quark_from_string("page_fault_exit");
4478 LTT_EVENT_PAGE_FAULT_NOSEM_ENTRY
= g_quark_from_string("page_fault_nosem_entry");
4479 LTT_EVENT_PAGE_FAULT_NOSEM_EXIT
= g_quark_from_string("page_fault_nosem_exit");
4480 LTT_EVENT_IRQ_ENTRY
= g_quark_from_string("irq_entry");
4481 LTT_EVENT_IRQ_EXIT
= g_quark_from_string("irq_exit");
4482 LTT_EVENT_SOFT_IRQ_RAISE
= g_quark_from_string("softirq_raise");
4483 LTT_EVENT_SOFT_IRQ_ENTRY
= g_quark_from_string("softirq_entry");
4484 LTT_EVENT_SOFT_IRQ_EXIT
= g_quark_from_string("softirq_exit");
4485 LTT_EVENT_SCHED_SCHEDULE
= g_quark_from_string("sched_schedule");
4486 LTT_EVENT_SCHED_TRY_WAKEUP
= g_quark_from_string("sched_try_wakeup");
4487 LTT_EVENT_PROCESS_FORK
= g_quark_from_string("process_fork");
4488 LTT_EVENT_KTHREAD_CREATE
= g_quark_from_string("kthread_create");
4489 LTT_EVENT_PROCESS_EXIT
= g_quark_from_string("process_exit");
4490 LTT_EVENT_PROCESS_FREE
= g_quark_from_string("process_free");
4491 LTT_EVENT_EXEC
= g_quark_from_string("exec");
4492 LTT_EVENT_PROCESS_STATE
= g_quark_from_string("process_state");
4493 LTT_EVENT_STATEDUMP_END
= g_quark_from_string("statedump_end");
4494 LTT_EVENT_FUNCTION_ENTRY
= g_quark_from_string("function_entry");
4495 LTT_EVENT_FUNCTION_EXIT
= g_quark_from_string("function_exit");
4496 LTT_EVENT_THREAD_BRAND
= g_quark_from_string("thread_brand");
4497 LTT_EVENT_REQUEST_ISSUE
= g_quark_from_string("_blk_request_issue");
4498 LTT_EVENT_REQUEST_COMPLETE
= g_quark_from_string("_blk_request_complete");
4499 LTT_EVENT_LIST_INTERRUPT
= g_quark_from_string("interrupt");
4500 LTT_EVENT_SYS_CALL_TABLE
= g_quark_from_string("sys_call_table");
4501 LTT_EVENT_SOFTIRQ_VEC
= g_quark_from_string("softirq_vec");
4502 LTT_EVENT_KPROBE_TABLE
= g_quark_from_string("kprobe_table");
4503 LTT_EVENT_KPROBE
= g_quark_from_string("kprobe");
4504 LTT_EVENT_OPEN
= g_quark_from_string("open");
4505 LTT_EVENT_READ
= g_quark_from_string("read");
4506 LTT_EVENT_POLL_EVENT
= g_quark_from_string("poll_event");
4508 LTT_FIELD_SYSCALL_ID
= g_quark_from_string("syscall_id");
4509 LTT_FIELD_TRAP_ID
= g_quark_from_string("trap_id");
4510 LTT_FIELD_IRQ_ID
= g_quark_from_string("irq_id");
4511 LTT_FIELD_SOFT_IRQ_ID
= g_quark_from_string("softirq_id");
4512 LTT_FIELD_PREV_PID
= g_quark_from_string("prev_pid");
4513 LTT_FIELD_NEXT_PID
= g_quark_from_string("next_pid");
4514 LTT_FIELD_PREV_STATE
= g_quark_from_string("prev_state");
4515 LTT_FIELD_PARENT_PID
= g_quark_from_string("parent_pid");
4516 LTT_FIELD_CHILD_PID
= g_quark_from_string("child_pid");
4517 LTT_FIELD_PID
= g_quark_from_string("pid");
4518 LTT_FIELD_TGID
= g_quark_from_string("tgid");
4519 LTT_FIELD_CHILD_TGID
= g_quark_from_string("child_tgid");
4520 LTT_FIELD_FILENAME
= g_quark_from_string("filename");
4521 LTT_FIELD_NAME
= g_quark_from_string("name");
4522 LTT_FIELD_TYPE
= g_quark_from_string("type");
4523 LTT_FIELD_MODE
= g_quark_from_string("mode");
4524 LTT_FIELD_SUBMODE
= g_quark_from_string("submode");
4525 LTT_FIELD_STATUS
= g_quark_from_string("status");
4526 LTT_FIELD_THIS_FN
= g_quark_from_string("this_fn");
4527 LTT_FIELD_CALL_SITE
= g_quark_from_string("call_site");
4528 LTT_FIELD_MAJOR
= g_quark_from_string("major");
4529 LTT_FIELD_MINOR
= g_quark_from_string("minor");
4530 LTT_FIELD_OPERATION
= g_quark_from_string("direction");
4531 LTT_FIELD_ACTION
= g_quark_from_string("action");
4532 LTT_FIELD_ID
= g_quark_from_string("id");
4533 LTT_FIELD_ADDRESS
= g_quark_from_string("address");
4534 LTT_FIELD_SYMBOL
= g_quark_from_string("symbol");
4535 LTT_FIELD_IP
= g_quark_from_string("ip");
4536 LTT_FIELD_FD
= g_quark_from_string("fd");
4537 LTT_FIELD_STATE
= g_quark_from_string("state");
4538 LTT_FIELD_CPU_ID
= g_quark_from_string("cpu_id");
4540 LTTV_CPU_UNKNOWN
= g_quark_from_string("unknown");
4541 LTTV_CPU_IDLE
= g_quark_from_string("idle");
4542 LTTV_CPU_BUSY
= g_quark_from_string("busy");
4543 LTTV_CPU_IRQ
= g_quark_from_string("irq");
4544 LTTV_CPU_SOFT_IRQ
= g_quark_from_string("softirq");
4545 LTTV_CPU_TRAP
= g_quark_from_string("trap");
4547 LTTV_IRQ_UNKNOWN
= g_quark_from_string("unknown");
4548 LTTV_IRQ_IDLE
= g_quark_from_string("idle");
4549 LTTV_IRQ_BUSY
= g_quark_from_string("busy");
4551 LTTV_BDEV_UNKNOWN
= g_quark_from_string("unknown");
4552 LTTV_BDEV_IDLE
= g_quark_from_string("idle");
4553 LTTV_BDEV_BUSY_READING
= g_quark_from_string("busy_reading");
4554 LTTV_BDEV_BUSY_WRITING
= g_quark_from_string("busy_writing");
4557 static void module_destroy()
4562 LTTV_MODULE("state", "State computation", \
4563 "Update the system state, possibly saving it at intervals", \
4564 module_init
, module_destroy
)