projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
thread fix
[lttv.git] / ltt / branches / poly / lttv / lttv / state.c
1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Michel Dagenais
3 *
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;
7 *
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.
12 *
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,
16 * MA 02111-1307, USA.
17 */
18
19 #ifdef HAVE_CONFIG_H
20 #include <config.h>
21 #endif
22
23 #include <lttv/lttv.h>
24 #include <lttv/module.h>
25 #include <lttv/state.h>
26 #include <ltt/facility.h>
27 #include <ltt/trace.h>
28 #include <ltt/event.h>
29 #include <ltt/type.h>
30 #include <stdio.h>
31 #include <string.h>
32
33 #define PREALLOCATED_EXECUTION_STACK 10
34
35 /* Facilities Quarks */
36
37 GQuark
38 LTT_FACILITY_KERNEL,
39 LTT_FACILITY_KERNEL_ARCH,
40 LTT_FACILITY_PROCESS,
41 LTT_FACILITY_FS,
42 LTT_FACILITY_STATEDUMP;
43
44 /* Events Quarks */
45
46 GQuark
47 LTT_EVENT_SYSCALL_ENTRY,
48 LTT_EVENT_SYSCALL_EXIT,
49 LTT_EVENT_TRAP_ENTRY,
50 LTT_EVENT_TRAP_EXIT,
51 LTT_EVENT_IRQ_ENTRY,
52 LTT_EVENT_IRQ_EXIT,
53 LTT_EVENT_SOFT_IRQ_ENTRY,
54 LTT_EVENT_SOFT_IRQ_EXIT,
55 LTT_EVENT_SCHEDCHANGE,
56 LTT_EVENT_FORK,
57 LTT_EVENT_KERNEL_THREAD,
58 LTT_EVENT_EXIT,
59 LTT_EVENT_FREE,
60 LTT_EVENT_EXEC,
61 LTT_EVENT_ENUM_PROCESS_STATE;
62
63 /* Fields Quarks */
64
65 GQuark
66 LTT_FIELD_SYSCALL_ID,
67 LTT_FIELD_TRAP_ID,
68 LTT_FIELD_IRQ_ID,
69 LTT_FIELD_SOFT_IRQ_ID,
70 LTT_FIELD_OUT,
71 LTT_FIELD_IN,
72 LTT_FIELD_OUT_STATE,
73 LTT_FIELD_PARENT_PID,
74 LTT_FIELD_CHILD_PID,
75 LTT_FIELD_PID,
76 LTT_FIELD_FILENAME,
77 LTT_FIELD_NAME,
78 LTT_FIELD_MODE,
79 LTT_FIELD_SUBMODE,
80 LTT_FIELD_STATUS;
81
82 LttvExecutionMode
83 LTTV_STATE_MODE_UNKNOWN,
84 LTTV_STATE_USER_MODE,
85 LTTV_STATE_SYSCALL,
86 LTTV_STATE_TRAP,
87 LTTV_STATE_IRQ,
88 LTTV_STATE_SOFT_IRQ;
89
90 LttvExecutionSubmode
91 LTTV_STATE_SUBMODE_UNKNOWN,
92 LTTV_STATE_SUBMODE_NONE;
93
94 LttvProcessStatus
95 LTTV_STATE_UNNAMED,
96 LTTV_STATE_WAIT_FORK,
97 LTTV_STATE_WAIT_CPU,
98 LTTV_STATE_EXIT,
99 LTTV_STATE_ZOMBIE,
100 LTTV_STATE_WAIT,
101 LTTV_STATE_RUN,
102 LTTV_STATE_DEAD;
103
104 static GQuark
105 LTTV_STATE_TRACEFILES,
106 LTTV_STATE_PROCESSES,
107 LTTV_STATE_PROCESS,
108 LTTV_STATE_RUNNING_PROCESS,
109 LTTV_STATE_EVENT,
110 LTTV_STATE_SAVED_STATES,
111 LTTV_STATE_SAVED_STATES_TIME,
112 LTTV_STATE_TIME,
113 LTTV_STATE_HOOKS,
114 LTTV_STATE_NAME_TABLES,
115 LTTV_STATE_TRACE_STATE_USE_COUNT;
116
117 static void create_max_time(LttvTraceState *tcs);
118
119 static void get_max_time(LttvTraceState *tcs);
120
121 static void free_max_time(LttvTraceState *tcs);
122
123 static void create_name_tables(LttvTraceState *tcs);
124
125 static void get_name_tables(LttvTraceState *tcs);
126
127 static void free_name_tables(LttvTraceState *tcs);
128
129 static void free_saved_state(LttvTraceState *tcs);
130
131 static void lttv_state_free_process_table(GHashTable *processes);
132
133
134 void lttv_state_save(LttvTraceState *self, LttvAttribute *container)
135 {
136 LTTV_TRACE_STATE_GET_CLASS(self)->state_save(self, container);
137 }
138
139
140 void lttv_state_restore(LttvTraceState *self, LttvAttribute *container)
141 {
142 LTTV_TRACE_STATE_GET_CLASS(self)->state_restore(self, container);
143 }
144
145
146 void lttv_state_state_saved_free(LttvTraceState *self,
147 LttvAttribute *container)
148 {
149 LTTV_TRACE_STATE_GET_CLASS(self)->state_saved_free(self, container);
150 }
151
152
153 guint process_hash(gconstpointer key)
154 {
155 guint pid = ((const LttvProcessState *)key)->pid;
156 return (pid>>8 ^ pid>>4 ^ pid>>2 ^ pid) ;
157 }
158
159
160 /* If the hash table hash function is well distributed,
161 * the process_equal should compare different pid */
162 gboolean process_equal(gconstpointer a, gconstpointer b)
163 {
164 const LttvProcessState *process_a, *process_b;
165 gboolean ret = TRUE;
166
167 process_a = (const LttvProcessState *)a;
168 process_b = (const LttvProcessState *)b;
169
170 if(likely(process_a->pid != process_b->pid)) ret = FALSE;
171 else if(likely(process_a->pid == 0 &&
172 process_a->cpu != process_b->cpu)) ret = FALSE;
173
174 return ret;
175 }
176
177
178 static void
179 restore_init_state(LttvTraceState *self)
180 {
181 guint i, nb_cpus;
182
183 LttvTracefileState *tfcs;
184
185 /* Free the process tables */
186 if(self->processes != NULL) lttv_state_free_process_table(self->processes);
187 self->processes = g_hash_table_new(process_hash, process_equal);
188 self->nb_event = 0;
189
190 /* Seek time to beginning */
191 // Mathieu : fix : don't seek traceset here : causes inconsistency in seek
192 // closest. It's the tracecontext job to seek the trace to the beginning
193 // anyway : the init state might be used at the middle of the trace as well...
194 //g_tree_destroy(self->parent.ts_context->pqueue);
195 //self->parent.ts_context->pqueue = g_tree_new(compare_tracefile);
196
197
198 //lttv_process_trace_seek_time(&self->parent, ltt_time_zero);
199
200 nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
201
202 /* Put the per cpu running_process to beginning state : process 0. */
203 for(i=0; i< nb_cpus; i++) {
204 self->running_process[i] = lttv_state_create_process(self, NULL, i, 0,
205 LTTV_STATE_UNNAMED, &ltt_time_zero);
206 self->running_process[i]->state->s = LTTV_STATE_RUN;
207 self->running_process[i]->cpu = i;
208 }
209
210 #if 0
211 nb_tracefile = self->parent.tracefiles->len;
212
213 for(i = 0 ; i < nb_tracefile ; i++) {
214 tfcs =
215 LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
216 LttvTracefileContext*, i));
217 ltt_trace_time_span_get(self->parent.t, &tfcs->parent.timestamp, NULL);
218 // tfcs->saved_position = 0;
219 tfcs->process = lttv_state_create_process(tfcs, NULL,0);
220 tfcs->process->state->s = LTTV_STATE_RUN;
221 tfcs->process->last_cpu = tfcs->cpu_name;
222 tfcs->process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfcs)->tf);
223 }
224 #endif //0
225 }
226
227 //static LttTime time_zero = {0,0};
228
229 static void
230 init(LttvTracesetState *self, LttvTraceset *ts)
231 {
232 guint i, j, nb_trace, nb_tracefile;
233
234 LttvTraceContext *tc;
235
236 LttvTraceState *tcs;
237
238 LttvTracefileState *tfcs;
239
240 LttvAttributeValue v;
241
242 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
243 init((LttvTracesetContext *)self, ts);
244
245 nb_trace = lttv_traceset_number(ts);
246 for(i = 0 ; i < nb_trace ; i++) {
247 tc = self->parent.traces[i];
248 tcs = LTTV_TRACE_STATE(tc);
249 tcs->save_interval = LTTV_STATE_SAVE_INTERVAL;
250 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_TRACE_STATE_USE_COUNT,
251 LTTV_UINT, &v);
252 (*v.v_uint)++;
253
254 if(*(v.v_uint) == 1) {
255 create_name_tables(tcs);
256 create_max_time(tcs);
257 }
258 get_name_tables(tcs);
259 get_max_time(tcs);
260
261 nb_tracefile = tc->tracefiles->len;
262 #if 0
263 for(j = 0 ; j < nb_tracefile ; j++) {
264 tfcs =
265 LTTV_TRACEFILE_STATE(g_array_index(tc->tracefiles,
266 LttvTracefileContext*, j));
267 tfcs->tracefile_name = ltt_tracefile_name(tfcs->parent.tf);
268 }
269 #endif //0
270 tcs->processes = NULL;
271 tcs->running_process = g_new(LttvProcessState*,
272 ltt_trace_get_num_cpu(tc->t));
273 restore_init_state(tcs);
274 }
275 }
276
277
278 static void
279 fini(LttvTracesetState *self)
280 {
281 guint i, nb_trace;
282
283 LttvTraceState *tcs;
284
285 LttvTracefileState *tfcs;
286
287 LttvAttributeValue v;
288
289 nb_trace = lttv_traceset_number(LTTV_TRACESET_CONTEXT(self)->ts);
290 for(i = 0 ; i < nb_trace ; i++) {
291 tcs = (LttvTraceState *)(LTTV_TRACESET_CONTEXT(self)->traces[i]);
292 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_TRACE_STATE_USE_COUNT,
293 LTTV_UINT, &v);
294
295 g_assert(*(v.v_uint) != 0);
296 (*v.v_uint)--;
297
298 if(*(v.v_uint) == 0) {
299 free_name_tables(tcs);
300 free_max_time(tcs);
301 free_saved_state(tcs);
302 }
303 g_free(tcs->running_process);
304 tcs->running_process = NULL;
305 lttv_state_free_process_table(tcs->processes);
306 tcs->processes = NULL;
307 }
308 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
309 fini((LttvTracesetContext *)self);
310 }
311
312
313 static LttvTracesetContext *
314 new_traceset_context(LttvTracesetContext *self)
315 {
316 return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE, NULL));
317 }
318
319
320 static LttvTraceContext *
321 new_trace_context(LttvTracesetContext *self)
322 {
323 return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE, NULL));
324 }
325
326
327 static LttvTracefileContext *
328 new_tracefile_context(LttvTracesetContext *self)
329 {
330 return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE, NULL));
331 }
332
333
334 /* Write the process state of the trace */
335
336 static void write_process_state(gpointer key, gpointer value,
337 gpointer user_data)
338 {
339 LttvProcessState *process;
340
341 LttvExecutionState *es;
342
343 FILE *fp = (FILE *)user_data;
344
345 guint i;
346
347 process = (LttvProcessState *)value;
348 fprintf(fp,
349 " <PROCESS CORE=%p PID=%u PPID=%u CTIME_S=%lu CTIME_NS=%lu NAME=\"%s\" CPU=\"%u\">\n",
350 process, process->pid, process->ppid, process->creation_time.tv_sec,
351 process->creation_time.tv_nsec, g_quark_to_string(process->name),
352 process->cpu);
353
354 for(i = 0 ; i < process->execution_stack->len; i++) {
355 es = &g_array_index(process->execution_stack, LttvExecutionState, i);
356 fprintf(fp, " <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
357 g_quark_to_string(es->t), g_quark_to_string(es->n),
358 es->entry.tv_sec, es->entry.tv_nsec);
359 fprintf(fp, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
360 es->change.tv_sec, es->change.tv_nsec, g_quark_to_string(es->s));
361 }
362 fprintf(fp, " </PROCESS>\n");
363 }
364
365
366 void lttv_state_write(LttvTraceState *self, LttTime t, FILE *fp)
367 {
368 guint i, nb_tracefile, nb_block, offset;
369 guint64 tsc;
370
371 LttvTracefileState *tfcs;
372
373 LttTracefile *tf;
374
375 LttEventPosition *ep;
376
377 guint nb_cpus;
378
379 ep = ltt_event_position_new();
380
381 fprintf(fp,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t.tv_sec, t.tv_nsec);
382
383 g_hash_table_foreach(self->processes, write_process_state, fp);
384
385 nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
386 for(i=0;i<nb_cpus;i++) {
387 fprintf(fp,"<CPU NUM=%u RUNNING_PROCESS=%u>\n",
388 i, self->running_process[i]->pid);
389 }
390
391 nb_tracefile = self->parent.tracefiles->len;
392
393 for(i = 0 ; i < nb_tracefile ; i++) {
394 tfcs =
395 LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
396 LttvTracefileContext*, i));
397 fprintf(fp, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
398 tfcs->parent.timestamp.tv_sec,
399 tfcs->parent.timestamp.tv_nsec);
400 LttEvent *e = ltt_tracefile_get_event(tfcs->parent.tf);
401 if(e == NULL) fprintf(fp,"/>\n");
402 else {
403 ltt_event_position(e, ep);
404 ltt_event_position_get(ep, &tf, &nb_block, &offset, &tsc);
405 fprintf(fp, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block, offset,
406 tsc);
407 }
408 }
409 g_free(ep);
410 fprintf(fp,"</PROCESS_STATE>");
411 }
412
413
414 /* Copy each process from an existing hash table to a new one */
415
416 static void copy_process_state(gpointer key, gpointer value,gpointer user_data)
417 {
418 LttvProcessState *process, *new_process;
419
420 GHashTable *new_processes = (GHashTable *)user_data;
421
422 guint i;
423
424 process = (LttvProcessState *)value;
425 new_process = g_new(LttvProcessState, 1);
426 *new_process = *process;
427 new_process->execution_stack = g_array_sized_new(FALSE, FALSE,
428 sizeof(LttvExecutionState), PREALLOCATED_EXECUTION_STACK);
429 new_process->execution_stack =
430 g_array_set_size(new_process->execution_stack,
431 process->execution_stack->len);
432 for(i = 0 ; i < process->execution_stack->len; i++) {
433 g_array_index(new_process->execution_stack, LttvExecutionState, i) =
434 g_array_index(process->execution_stack, LttvExecutionState, i);
435 }
436 new_process->state = &g_array_index(new_process->execution_stack,
437 LttvExecutionState, new_process->execution_stack->len - 1);
438 g_hash_table_insert(new_processes, new_process, new_process);
439 }
440
441
442 static GHashTable *lttv_state_copy_process_table(GHashTable *processes)
443 {
444 GHashTable *new_processes = g_hash_table_new(process_hash, process_equal);
445
446 g_hash_table_foreach(processes, copy_process_state, new_processes);
447 return new_processes;
448 }
449
450
451 /* The saved state for each trace contains a member "processes", which
452 stores a copy of the process table, and a member "tracefiles" with
453 one entry per tracefile. Each tracefile has a "process" member pointing
454 to the current process and a "position" member storing the tracefile
455 position (needed to seek to the current "next" event. */
456
457 static void state_save(LttvTraceState *self, LttvAttribute *container)
458 {
459 guint i, nb_tracefile, nb_cpus;
460
461 LttvTracefileState *tfcs;
462
463 LttvAttribute *tracefiles_tree, *tracefile_tree;
464
465 guint *running_process;
466
467 LttvAttributeType type;
468
469 LttvAttributeValue value;
470
471 LttvAttributeName name;
472
473 LttEventPosition *ep;
474
475 tracefiles_tree = lttv_attribute_find_subdir(container,
476 LTTV_STATE_TRACEFILES);
477
478 value = lttv_attribute_add(container, LTTV_STATE_PROCESSES,
479 LTTV_POINTER);
480 *(value.v_pointer) = lttv_state_copy_process_table(self->processes);
481
482 /* Add the currently running processes array */
483 nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
484 running_process = g_new(guint, nb_cpus);
485 for(i=0;i<nb_cpus;i++) {
486 running_process[i] = self->running_process[i]->pid;
487 }
488 value = lttv_attribute_add(container, LTTV_STATE_RUNNING_PROCESS,
489 LTTV_POINTER);
490 *(value.v_pointer) = running_process;
491
492 g_info("State save");
493
494 nb_tracefile = self->parent.tracefiles->len;
495
496 for(i = 0 ; i < nb_tracefile ; i++) {
497 tfcs =
498 LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
499 LttvTracefileContext*, i));
500 tracefile_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
501 value = lttv_attribute_add(tracefiles_tree, i,
502 LTTV_GOBJECT);
503 *(value.v_gobject) = (GObject *)tracefile_tree;
504 #if 0
505 value = lttv_attribute_add(tracefile_tree, LTTV_STATE_PROCESS,
506 LTTV_UINT);
507 *(value.v_uint) = tfcs->process->pid;
508 #endif //0
509 value = lttv_attribute_add(tracefile_tree, LTTV_STATE_EVENT,
510 LTTV_POINTER);
511 /* Only save the position if the tfs has not infinite time. */
512 //if(!g_tree_lookup(self->parent.ts_context->pqueue, &tfcs->parent)
513 // && current_tfcs != tfcs) {
514 if(ltt_time_compare(tfcs->parent.timestamp, ltt_time_infinite) == 0) {
515 *(value.v_pointer) = NULL;
516 } else {
517 LttEvent *e = ltt_tracefile_get_event(tfcs->parent.tf);
518 ep = ltt_event_position_new();
519 ltt_event_position(e, ep);
520 *(value.v_pointer) = ep;
521
522 guint nb_block, offset;
523 guint64 tsc;
524 LttTracefile *tf;
525 ltt_event_position_get(ep, &tf, &nb_block, &offset, &tsc);
526 g_info("Block %u offset %u tsc %llu time %lu.%lu", nb_block, offset,
527 tsc,
528 tfcs->parent.timestamp.tv_sec, tfcs->parent.timestamp.tv_nsec);
529 }
530 }
531 }
532
533
534 static void state_restore(LttvTraceState *self, LttvAttribute *container)
535 {
536 guint i, nb_tracefile, pid, nb_cpus;
537
538 LttvTracefileState *tfcs;
539
540 LttvAttribute *tracefiles_tree, *tracefile_tree;
541
542 guint *running_process;
543
544 LttvAttributeType type;
545
546 LttvAttributeValue value;
547
548 LttvAttributeName name;
549
550 LttEventPosition *ep;
551
552 LttvTracesetContext *tsc = self->parent.ts_context;
553
554 tracefiles_tree = lttv_attribute_find_subdir(container,
555 LTTV_STATE_TRACEFILES);
556
557 type = lttv_attribute_get_by_name(container, LTTV_STATE_PROCESSES,
558 &value);
559 g_assert(type == LTTV_POINTER);
560 lttv_state_free_process_table(self->processes);
561 self->processes = lttv_state_copy_process_table(*(value.v_pointer));
562
563 /* Add the currently running processes array */
564 nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
565 type = lttv_attribute_get_by_name(container, LTTV_STATE_RUNNING_PROCESS,
566 &value);
567 g_assert(type == LTTV_POINTER);
568 running_process = *(value.v_pointer);
569 for(i=0;i<nb_cpus;i++) {
570 pid = running_process[i];
571 self->running_process[i] = lttv_state_find_process(self, i, pid);
572 g_assert(self->running_process[i] != NULL);
573 }
574
575
576 nb_tracefile = self->parent.tracefiles->len;
577
578 //g_tree_destroy(tsc->pqueue);
579 //tsc->pqueue = g_tree_new(compare_tracefile);
580
581 for(i = 0 ; i < nb_tracefile ; i++) {
582 tfcs =
583 LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
584 LttvTracefileContext*, i));
585 type = lttv_attribute_get(tracefiles_tree, i, &name, &value);
586 g_assert(type == LTTV_GOBJECT);
587 tracefile_tree = *((LttvAttribute **)(value.v_gobject));
588 #if 0
589 type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_PROCESS,
590 &value);
591 g_assert(type == LTTV_UINT);
592 pid = *(value.v_uint);
593 tfcs->process = lttv_state_find_process_or_create(tfcs, pid);
594 #endif //0
595 type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_EVENT,
596 &value);
597 g_assert(type == LTTV_POINTER);
598 //g_assert(*(value.v_pointer) != NULL);
599 ep = *(value.v_pointer);
600 g_assert(tfcs->parent.t_context != NULL);
601
602 LttvTracefileContext *tfc = LTTV_TRACEFILE_CONTEXT(tfcs);
603 g_tree_remove(tsc->pqueue, tfc);
604
605 if(ep != NULL) {
606 g_assert(ltt_tracefile_seek_position(tfc->tf, ep) == 0);
607 tfc->timestamp = ltt_event_time(ltt_tracefile_get_event(tfc->tf));
608 g_assert(ltt_time_compare(tfc->timestamp, ltt_time_infinite) != 0);
609 g_tree_insert(tsc->pqueue, tfc, tfc);
610 g_info("Restoring state for a tf at time %lu.%lu", tfc->timestamp.tv_sec, tfc->timestamp.tv_nsec);
611 } else {
612 tfc->timestamp = ltt_time_infinite;
613 }
614 }
615 }
616
617
618 static void state_saved_free(LttvTraceState *self, LttvAttribute *container)
619 {
620 guint i, nb_tracefile, nb_cpus;
621
622 LttvTracefileState *tfcs;
623
624 LttvAttribute *tracefiles_tree, *tracefile_tree;
625
626 guint *running_process;
627
628 LttvAttributeType type;
629
630 LttvAttributeValue value;
631
632 LttvAttributeName name;
633
634 LttEventPosition *ep;
635
636 tracefiles_tree = lttv_attribute_find_subdir(container,
637 LTTV_STATE_TRACEFILES);
638 g_object_ref(G_OBJECT(tracefiles_tree));
639 lttv_attribute_remove_by_name(container, LTTV_STATE_TRACEFILES);
640
641 type = lttv_attribute_get_by_name(container, LTTV_STATE_PROCESSES,
642 &value);
643 g_assert(type == LTTV_POINTER);
644 lttv_state_free_process_table(*(value.v_pointer));
645 *(value.v_pointer) = NULL;
646 lttv_attribute_remove_by_name(container, LTTV_STATE_PROCESSES);
647
648 /* Free running processes array */
649 nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
650 type = lttv_attribute_get_by_name(container, LTTV_STATE_RUNNING_PROCESS,
651 &value);
652 g_assert(type == LTTV_POINTER);
653 running_process = *(value.v_pointer);
654 g_free(running_process);
655
656 nb_tracefile = self->parent.tracefiles->len;
657
658 for(i = 0 ; i < nb_tracefile ; i++) {
659 tfcs =
660 LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
661 LttvTracefileContext*, i));
662 type = lttv_attribute_get(tracefiles_tree, i, &name, &value);
663 g_assert(type == LTTV_GOBJECT);
664 tracefile_tree = *((LttvAttribute **)(value.v_gobject));
665
666 type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_EVENT,
667 &value);
668 g_assert(type == LTTV_POINTER);
669 if(*(value.v_pointer) != NULL) g_free(*(value.v_pointer));
670 }
671 g_object_unref(G_OBJECT(tracefiles_tree));
672 }
673
674
675 static void free_saved_state(LttvTraceState *self)
676 {
677 guint i, nb;
678
679 LttvAttributeType type;
680
681 LttvAttributeValue value;
682
683 LttvAttributeName name;
684
685 LttvAttribute *saved_states;
686
687 saved_states = lttv_attribute_find_subdir(self->parent.t_a,
688 LTTV_STATE_SAVED_STATES);
689
690 nb = lttv_attribute_get_number(saved_states);
691 for(i = 0 ; i < nb ; i++) {
692 type = lttv_attribute_get(saved_states, i, &name, &value);
693 g_assert(type == LTTV_GOBJECT);
694 state_saved_free(self, *((LttvAttribute **)value.v_gobject));
695 }
696
697 lttv_attribute_remove_by_name(self->parent.t_a, LTTV_STATE_SAVED_STATES);
698 }
699
700
701 static void
702 create_max_time(LttvTraceState *tcs)
703 {
704 LttvAttributeValue v;
705
706 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_SAVED_STATES_TIME,
707 LTTV_POINTER, &v);
708 g_assert(*(v.v_pointer) == NULL);
709 *(v.v_pointer) = g_new(LttTime,1);
710 *((LttTime *)*(v.v_pointer)) = ltt_time_zero;
711 }
712
713
714 static void
715 get_max_time(LttvTraceState *tcs)
716 {
717 LttvAttributeValue v;
718
719 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_SAVED_STATES_TIME,
720 LTTV_POINTER, &v);
721 g_assert(*(v.v_pointer) != NULL);
722 tcs->max_time_state_recomputed_in_seek = (LttTime *)*(v.v_pointer);
723 }
724
725
726 static void
727 free_max_time(LttvTraceState *tcs)
728 {
729 LttvAttributeValue v;
730
731 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_SAVED_STATES_TIME,
732 LTTV_POINTER, &v);
733 g_free(*(v.v_pointer));
734 *(v.v_pointer) = NULL;
735 }
736
737
738 typedef struct _LttvNameTables {
739 // FIXME GQuark *eventtype_names;
740 GQuark *syscall_names;
741 GQuark *trap_names;
742 GQuark *irq_names;
743 GQuark *soft_irq_names;
744 } LttvNameTables;
745
746
747 static void
748 create_name_tables(LttvTraceState *tcs)
749 {
750 int i, nb;
751
752 GQuark f_name, e_name;
753
754 LttvTraceHook h;
755
756 LttvTraceHookByFacility *thf;
757
758 LttEventType *et;
759
760 LttType *t;
761
762 GString *fe_name = g_string_new("");
763
764 LttvNameTables *name_tables = g_new(LttvNameTables, 1);
765
766 LttvAttributeValue v;
767
768 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
769 LTTV_POINTER, &v);
770 g_assert(*(v.v_pointer) == NULL);
771 *(v.v_pointer) = name_tables;
772 #if 0 // Use iteration over the facilities_by_name and then list all event
773 // types of each facility
774 nb = ltt_trace_eventtype_number(tcs->parent.t);
775 name_tables->eventtype_names = g_new(GQuark, nb);
776 for(i = 0 ; i < nb ; i++) {
777 et = ltt_trace_eventtype_get(tcs->parent.t, i);
778 e_name = ltt_eventtype_name(et);
779 f_name = ltt_facility_name(ltt_eventtype_facility(et));
780 g_string_printf(fe_name, "%s.%s", f_name, e_name);
781 name_tables->eventtype_names[i] = g_quark_from_string(fe_name->str);
782 }
783 #endif //0
784 if(lttv_trace_find_hook(tcs->parent.t,
785 LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY,
786 LTT_FIELD_SYSCALL_ID, 0, 0,
787 NULL, NULL, &h))
788 return;
789
790 thf = lttv_trace_hook_get_first(&h);
791
792 t = ltt_field_type(thf->f1);
793 nb = ltt_type_element_number(t);
794
795 lttv_trace_hook_destroy(&h);
796
797 name_tables->syscall_names = g_new(GQuark, nb);
798
799 for(i = 0 ; i < nb ; i++) {
800 name_tables->syscall_names[i] = ltt_enum_string_get(t, i);
801 }
802
803 //name_tables->syscall_names = g_new(GQuark, 256);
804 //for(i = 0 ; i < 256 ; i++) {
805 // g_string_printf(fe_name, "syscall %d", i);
806 // name_tables->syscall_names[i] = g_quark_from_string(fe_name->str);
807 //}
808
809 if(lttv_trace_find_hook(tcs->parent.t, LTT_FACILITY_KERNEL,
810 LTT_EVENT_TRAP_ENTRY,
811 LTT_FIELD_TRAP_ID, 0, 0,
812 NULL, NULL, &h))
813 return;
814
815 thf = lttv_trace_hook_get_first(&h);
816
817 t = ltt_field_type(thf->f1);
818 //nb = ltt_type_element_number(t);
819
820 lttv_trace_hook_destroy(&h);
821
822 /*
823 name_tables->trap_names = g_new(GQuark, nb);
824 for(i = 0 ; i < nb ; i++) {
825 name_tables->trap_names[i] = g_quark_from_string(
826 ltt_enum_string_get(t, i));
827 }
828 */
829
830 name_tables->trap_names = g_new(GQuark, 256);
831 for(i = 0 ; i < 256 ; i++) {
832 g_string_printf(fe_name, "trap %d", i);
833 name_tables->trap_names[i] = g_quark_from_string(fe_name->str);
834 }
835
836 if(lttv_trace_find_hook(tcs->parent.t,
837 LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY,
838 LTT_FIELD_IRQ_ID, 0, 0,
839 NULL, NULL, &h))
840 return;
841
842 thf = lttv_trace_hook_get_first(&h);
843
844 t = ltt_field_type(thf->f1);
845 //nb = ltt_type_element_number(t);
846
847 lttv_trace_hook_destroy(&h);
848
849 /*
850 name_tables->irq_names = g_new(GQuark, nb);
851 for(i = 0 ; i < nb ; i++) {
852 name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
853 }
854 */
855
856 name_tables->irq_names = g_new(GQuark, 256);
857 for(i = 0 ; i < 256 ; i++) {
858 g_string_printf(fe_name, "irq %d", i);
859 name_tables->irq_names[i] = g_quark_from_string(fe_name->str);
860 }
861
862 /*
863 name_tables->soft_irq_names = g_new(GQuark, nb);
864 for(i = 0 ; i < nb ; i++) {
865 name_tables->soft_irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
866 }
867 */
868
869 name_tables->soft_irq_names = g_new(GQuark, 256);
870 for(i = 0 ; i < 256 ; i++) {
871 g_string_printf(fe_name, "softirq %d", i);
872 name_tables->soft_irq_names[i] = g_quark_from_string(fe_name->str);
873 }
874
875
876 g_string_free(fe_name, TRUE);
877 }
878
879
880 static void
881 get_name_tables(LttvTraceState *tcs)
882 {
883 LttvNameTables *name_tables;
884
885 LttvAttributeValue v;
886
887 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
888 LTTV_POINTER, &v);
889 g_assert(*(v.v_pointer) != NULL);
890 name_tables = (LttvNameTables *)*(v.v_pointer);
891 //tcs->eventtype_names = name_tables->eventtype_names;
892 tcs->syscall_names = name_tables->syscall_names;
893 tcs->trap_names = name_tables->trap_names;
894 tcs->irq_names = name_tables->irq_names;
895 tcs->soft_irq_names = name_tables->soft_irq_names;
896 }
897
898
899 static void
900 free_name_tables(LttvTraceState *tcs)
901 {
902 LttvNameTables *name_tables;
903
904 LttvAttributeValue v;
905
906 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
907 LTTV_POINTER, &v);
908 name_tables = (LttvNameTables *)*(v.v_pointer);
909 *(v.v_pointer) = NULL;
910
911 // g_free(name_tables->eventtype_names);
912 g_free(name_tables->syscall_names);
913 g_free(name_tables->trap_names);
914 g_free(name_tables->irq_names);
915 g_free(name_tables->soft_irq_names);
916 g_free(name_tables);
917 }
918
919 #ifdef HASH_TABLE_DEBUG
920
921 static void test_process(gpointer key, gpointer value, gpointer user_data)
922 {
923 LttvProcessState *process = (LttvProcessState *)value;
924
925 /* Test for process corruption */
926 guint stack_len = process->execution_stack->len;
927 }
928
929 static void hash_table_check(GHashTable *table)
930 {
931 g_hash_table_foreach(table, test_process, NULL);
932 }
933
934
935 #endif
936
937
938 static void push_state(LttvTracefileState *tfs, LttvExecutionMode t,
939 guint state_id)
940 {
941 LttvExecutionState *es;
942
943 guint cpu = ltt_tracefile_num(tfs->parent.tf);
944 LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
945
946 #ifdef HASH_TABLE_DEBUG
947 hash_table_check(ts->processes);
948 #endif
949 LttvProcessState *process = ts->running_process[cpu];
950
951 guint depth = process->execution_stack->len;
952
953 process->execution_stack =
954 g_array_set_size(process->execution_stack, depth + 1);
955 /* Keep in sync */
956 process->state =
957 &g_array_index(process->execution_stack, LttvExecutionState, depth - 1);
958
959 es = &g_array_index(process->execution_stack, LttvExecutionState, depth);
960 es->t = t;
961 es->n = state_id;
962 es->entry = es->change = tfs->parent.timestamp;
963 es->s = process->state->s;
964 process->state = es;
965 }
966
967
968 static void pop_state(LttvTracefileState *tfs, LttvExecutionMode t)
969 {
970 guint cpu = ltt_tracefile_num(tfs->parent.tf);
971 LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
972 LttvProcessState *process = ts->running_process[cpu];
973
974 guint depth = process->execution_stack->len;
975
976 if(process->state->t != t){
977 g_info("Different execution mode type (%lu.%09lu): ignore it\n",
978 tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
979 g_info("process state has %s when pop_int is %s\n",
980 g_quark_to_string(process->state->t),
981 g_quark_to_string(t));
982 g_info("{ %u, %u, %s, %s }\n",
983 process->pid,
984 process->ppid,
985 g_quark_to_string(process->name),
986 g_quark_to_string(process->state->s));
987 return;
988 }
989
990 if(depth == 1){
991 g_info("Trying to pop last state on stack (%lu.%09lu): ignore it\n",
992 tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
993 return;
994 }
995
996 process->execution_stack =
997 g_array_set_size(process->execution_stack, depth - 1);
998 process->state = &g_array_index(process->execution_stack, LttvExecutionState,
999 depth - 2);
1000 process->state->change = tfs->parent.timestamp;
1001 }
1002
1003
1004 LttvProcessState *
1005 lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent,
1006 guint cpu, guint pid, GQuark name, const LttTime *timestamp)
1007 {
1008 LttvProcessState *process = g_new(LttvProcessState, 1);
1009
1010 LttvExecutionState *es;
1011
1012 LttvTraceContext *tc = (LttvTraceContext*)tcs;
1013
1014 char buffer[128];
1015
1016 process->pid = pid;
1017 process->cpu = cpu;
1018 process->name = name;
1019 //process->last_cpu = tfs->cpu_name;
1020 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
1021 process->kernel_thread = 0;
1022
1023 g_info("Process %u, core %p", process->pid, process);
1024 g_hash_table_insert(tcs->processes, process, process);
1025
1026 if(parent) {
1027 process->ppid = parent->pid;
1028 process->creation_time = *timestamp;
1029 }
1030
1031 /* No parent. This process exists but we are missing all information about
1032 its creation. The birth time is set to zero but we remember the time of
1033 insertion */
1034
1035 else {
1036 process->ppid = 0;
1037 process->creation_time = ltt_time_zero;
1038 }
1039
1040 process->insertion_time = *timestamp;
1041 sprintf(buffer,"%d-%lu.%lu",pid, process->creation_time.tv_sec,
1042 process->creation_time.tv_nsec);
1043 process->pid_time = g_quark_from_string(buffer);
1044 process->cpu = cpu;
1045 //process->last_cpu = tfs->cpu_name;
1046 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
1047 process->execution_stack = g_array_sized_new(FALSE, FALSE,
1048 sizeof(LttvExecutionState), PREALLOCATED_EXECUTION_STACK);
1049 process->execution_stack = g_array_set_size(process->execution_stack, 2);
1050 es = process->state = &g_array_index(process->execution_stack,
1051 LttvExecutionState, 0);
1052 es->t = LTTV_STATE_USER_MODE;
1053 es->n = LTTV_STATE_SUBMODE_NONE;
1054 es->entry = *timestamp;
1055 //g_assert(timestamp->tv_sec != 0);
1056 es->change = *timestamp;
1057 es->s = LTTV_STATE_RUN;
1058
1059 es = process->state = &g_array_index(process->execution_stack,
1060 LttvExecutionState, 1);
1061 es->t = LTTV_STATE_SYSCALL;
1062 es->n = LTTV_STATE_SUBMODE_NONE;
1063 es->entry = *timestamp;
1064 //g_assert(timestamp->tv_sec != 0);
1065 es->change = *timestamp;
1066 es->s = LTTV_STATE_WAIT_FORK;
1067
1068 return process;
1069 }
1070
1071 LttvProcessState *lttv_state_find_process(LttvTraceState *ts, guint cpu,
1072 guint pid)
1073 {
1074 LttvProcessState key;
1075 LttvProcessState *process;
1076
1077 key.pid = pid;
1078 key.cpu = cpu;
1079 process = g_hash_table_lookup(ts->processes, &key);
1080 return process;
1081 }
1082
1083 LttvProcessState *
1084 lttv_state_find_process_or_create(LttvTraceState *ts, guint cpu, guint pid,
1085 LttTime *timestamp)
1086 {
1087 LttvProcessState *process = lttv_state_find_process(ts, cpu, pid);
1088 LttvExecutionState *es;
1089
1090 /* Put ltt_time_zero creation time for unexisting processes */
1091 if(unlikely(process == NULL)) {
1092 process = lttv_state_create_process(ts,
1093 NULL, cpu, pid, LTTV_STATE_UNNAMED, timestamp);
1094 /* We are not sure is it's a kernel thread or normal thread, put the
1095 * bottom stack state to unknown */
1096 es = &g_array_index(process->execution_stack, LttvExecutionState, 0);
1097 es->t = LTTV_STATE_MODE_UNKNOWN;
1098 }
1099 return process;
1100 }
1101
1102 /* FIXME : this function should be called when we receive an event telling that
1103 * release_task has been called in the kernel. In happens generally when
1104 * the parent waits for its child terminaison, but may also happen in special
1105 * cases in the child's exit : when the parent ignores its children SIGCCHLD or
1106 * has the flag SA_NOCLDWAIT. It can also happen when the child is part
1107 * of a killed thread ground, but isn't the leader.
1108 */
1109 static void exit_process(LttvTracefileState *tfs, LttvProcessState *process)
1110 {
1111 LttvTraceState *ts = LTTV_TRACE_STATE(tfs->parent.t_context);
1112 LttvProcessState key;
1113
1114 key.pid = process->pid;
1115 key.cpu = process->cpu;
1116 g_hash_table_remove(ts->processes, &key);
1117 g_array_free(process->execution_stack, TRUE);
1118 g_free(process);
1119 }
1120
1121
1122 static void free_process_state(gpointer key, gpointer value,gpointer user_data)
1123 {
1124 g_array_free(((LttvProcessState *)value)->execution_stack, TRUE);
1125 g_free(value);
1126 }
1127
1128
1129 static void lttv_state_free_process_table(GHashTable *processes)
1130 {
1131 g_hash_table_foreach(processes, free_process_state, NULL);
1132 g_hash_table_destroy(processes);
1133 }
1134
1135
1136 static gboolean syscall_entry(void *hook_data, void *call_data)
1137 {
1138 LttvTracefileState *s = (LttvTracefileState *)call_data;
1139 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1140 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1141 LttField *f = thf->f1;
1142
1143 LttvExecutionSubmode submode;
1144
1145 submode = ((LttvTraceState *)(s->parent.t_context))->syscall_names[
1146 ltt_event_get_unsigned(e, f)];
1147 push_state(s, LTTV_STATE_SYSCALL, submode);
1148 return FALSE;
1149 }
1150
1151
1152 static gboolean syscall_exit(void *hook_data, void *call_data)
1153 {
1154 LttvTracefileState *s = (LttvTracefileState *)call_data;
1155
1156 pop_state(s, LTTV_STATE_SYSCALL);
1157 return FALSE;
1158 }
1159
1160
1161 static gboolean trap_entry(void *hook_data, void *call_data)
1162 {
1163 LttvTracefileState *s = (LttvTracefileState *)call_data;
1164 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1165 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1166 LttField *f = thf->f1;
1167
1168 LttvExecutionSubmode submode;
1169
1170 submode = ((LttvTraceState *)(s->parent.t_context))->trap_names[
1171 ltt_event_get_unsigned(e, f)];
1172 push_state(s, LTTV_STATE_TRAP, submode);
1173 return FALSE;
1174 }
1175
1176
1177 static gboolean trap_exit(void *hook_data, void *call_data)
1178 {
1179 LttvTracefileState *s = (LttvTracefileState *)call_data;
1180
1181 pop_state(s, LTTV_STATE_TRAP);
1182 return FALSE;
1183 }
1184
1185
1186 static gboolean irq_entry(void *hook_data, void *call_data)
1187 {
1188 LttvTracefileState *s = (LttvTracefileState *)call_data;
1189 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1190 guint8 fac_id = ltt_event_facility_id(e);
1191 guint8 ev_id = ltt_event_eventtype_id(e);
1192 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1193 // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
1194 g_assert(thf->f1 != NULL);
1195 // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
1196 LttField *f = thf->f1;
1197
1198 LttvExecutionSubmode submode;
1199
1200 submode = ((LttvTraceState *)(s->parent.t_context))->irq_names[
1201 ltt_event_get_unsigned(e, f)];
1202
1203 /* Do something with the info about being in user or system mode when int? */
1204 push_state(s, LTTV_STATE_IRQ, submode);
1205 return FALSE;
1206 }
1207
1208
1209 static gboolean irq_exit(void *hook_data, void *call_data)
1210 {
1211 LttvTracefileState *s = (LttvTracefileState *)call_data;
1212
1213 pop_state(s, LTTV_STATE_IRQ);
1214 return FALSE;
1215 }
1216
1217 static gboolean soft_irq_entry(void *hook_data, void *call_data)
1218 {
1219 LttvTracefileState *s = (LttvTracefileState *)call_data;
1220 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1221 guint8 fac_id = ltt_event_facility_id(e);
1222 guint8 ev_id = ltt_event_eventtype_id(e);
1223 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1224 // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
1225 g_assert(thf->f1 != NULL);
1226 // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
1227 LttField *f = thf->f1;
1228
1229 LttvExecutionSubmode submode;
1230
1231 submode = ((LttvTraceState *)(s->parent.t_context))->soft_irq_names[
1232 ltt_event_get_unsigned(e, f)];
1233
1234 /* Do something with the info about being in user or system mode when int? */
1235 push_state(s, LTTV_STATE_SOFT_IRQ, submode);
1236 return FALSE;
1237 }
1238
1239
1240 static gboolean soft_irq_exit(void *hook_data, void *call_data)
1241 {
1242 LttvTracefileState *s = (LttvTracefileState *)call_data;
1243
1244 pop_state(s, LTTV_STATE_SOFT_IRQ);
1245 return FALSE;
1246 }
1247
1248
1249 static gboolean schedchange(void *hook_data, void *call_data)
1250 {
1251 LttvTracefileState *s = (LttvTracefileState *)call_data;
1252 guint cpu = ltt_tracefile_num(s->parent.tf);
1253 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
1254 LttvProcessState *process = ts->running_process[cpu];
1255 LttvProcessState *old_process = ts->running_process[cpu];
1256
1257 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1258 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1259 guint pid_in, pid_out;
1260 gint state_out;
1261
1262 pid_out = ltt_event_get_unsigned(e, thf->f1);
1263 pid_in = ltt_event_get_unsigned(e, thf->f2);
1264 state_out = ltt_event_get_int(e, thf->f3);
1265
1266 if(likely(process != NULL)) {
1267
1268 /* We could not know but it was not the idle process executing.
1269 This should only happen at the beginning, before the first schedule
1270 event, and when the initial information (current process for each CPU)
1271 is missing. It is not obvious how we could, after the fact, compensate
1272 the wrongly attributed statistics. */
1273
1274 //This test only makes sense once the state is known and if there is no
1275 //missing events. We need to silently ignore schedchange coming after a
1276 //process_free, or it causes glitches. (FIXME)
1277 //if(unlikely(process->pid != pid_out)) {
1278 // g_assert(process->pid == 0);
1279 //}
1280
1281 if(unlikely(process->state->s == LTTV_STATE_EXIT)) {
1282 process->state->s = LTTV_STATE_ZOMBIE;
1283 process->state->change = s->parent.timestamp;
1284 } else {
1285 if(unlikely(state_out == 0)) process->state->s = LTTV_STATE_WAIT_CPU;
1286 else process->state->s = LTTV_STATE_WAIT;
1287 process->state->change = s->parent.timestamp;
1288 }
1289
1290 if(state_out == 32)
1291 exit_process(s, process); /* EXIT_DEAD */
1292 /* see sched.h for states */
1293 }
1294 process = ts->running_process[cpu] =
1295 lttv_state_find_process_or_create(
1296 (LttvTraceState*)s->parent.t_context,
1297 cpu, pid_in,
1298 &s->parent.timestamp);
1299 process->state->s = LTTV_STATE_RUN;
1300 process->cpu = cpu;
1301 // process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)s)->tf);
1302 process->state->change = s->parent.timestamp;
1303 return FALSE;
1304 }
1305
1306 static gboolean process_fork(void *hook_data, void *call_data)
1307 {
1308 LttvTracefileState *s = (LttvTracefileState *)call_data;
1309 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1310 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1311 guint parent_pid;
1312 guint child_pid;
1313 LttvProcessState *zombie_process;
1314 guint cpu = ltt_tracefile_num(s->parent.tf);
1315 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
1316 LttvProcessState *process = ts->running_process[cpu];
1317 LttvProcessState *child_process;
1318
1319 /* Parent PID */
1320 parent_pid = ltt_event_get_unsigned(e, thf->f1);
1321
1322 /* Child PID */
1323 child_pid = ltt_event_get_unsigned(e, thf->f2);
1324
1325 /* Mathieu : it seems like the process might have been scheduled in before the
1326 * fork, and, in a rare case, might be the current process. This might happen
1327 * in a SMP case where we don't have enough precision on the clocks.
1328 *
1329 * Test reenabled after precision fixes on time. (Mathieu) */
1330 #if 0
1331 zombie_process = lttv_state_find_process(ts, ANY_CPU, child_pid);
1332
1333 if(unlikely(zombie_process != NULL)) {
1334 /* Reutilisation of PID. Only now we are sure that the old PID
1335 * has been released. FIXME : should know when release_task happens instead.
1336 */
1337 guint num_cpus = ltt_trace_get_num_cpu(ts->parent.t);
1338 guint i;
1339 for(i=0; i< num_cpus; i++) {
1340 g_assert(zombie_process != ts->running_process[i]);
1341 }
1342
1343 exit_process(s, zombie_process);
1344 }
1345 #endif //0
1346 g_assert(process->pid != child_pid);
1347 // FIXME : Add this test in the "known state" section
1348 // g_assert(process->pid == parent_pid);
1349 child_process = lttv_state_find_process(ts, ANY_CPU, child_pid);
1350 if(child_process == NULL) {
1351 child_process = lttv_state_create_process(ts, process, cpu,
1352 child_pid, LTTV_STATE_UNNAMED, &s->parent.timestamp);
1353 } else {
1354 /* The process has already been created : due to time imprecision between
1355 * multiple CPUs : it has been scheduled in before creation. Note that we
1356 * shouldn't have this kind of imprecision.
1357 *
1358 * Simply put a correct parent.
1359 */
1360 g_assert(0); /* This is a problematic case : the process has been created
1361 before the fork event */
1362 child_process->ppid = process->pid;
1363 }
1364 g_assert(child_process->name == LTTV_STATE_UNNAMED);
1365 child_process->name = process->name;
1366
1367 return FALSE;
1368 }
1369
1370 /* We stamp a newly created process as kernel_thread */
1371 static gboolean process_kernel_thread(void *hook_data, void *call_data)
1372 {
1373 LttvTracefileState *s = (LttvTracefileState *)call_data;
1374 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1375 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1376 guint pid;
1377 guint cpu = ltt_tracefile_num(s->parent.tf);
1378 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
1379 LttvProcessState *process;
1380 LttvExecutionState *es;
1381
1382 /* PID */
1383 pid = ltt_event_get_unsigned(e, thf->f1);
1384
1385 process = lttv_state_find_process(ts, ANY_CPU, pid);
1386 es = &g_array_index(process->execution_stack, LttvExecutionState, 0);
1387 es->t = LTTV_STATE_SYSCALL;
1388 process->kernel_thread = 1;
1389
1390 return FALSE;
1391 }
1392
1393 static gboolean process_exit(void *hook_data, void *call_data)
1394 {
1395 LttvTracefileState *s = (LttvTracefileState *)call_data;
1396 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1397 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1398 LttField *f;
1399 guint pid;
1400 guint cpu = ltt_tracefile_num(s->parent.tf);
1401 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
1402 LttvProcessState *process = ts->running_process[cpu];
1403
1404 pid = ltt_event_get_unsigned(e, thf->f1);
1405
1406 // FIXME : Add this test in the "known state" section
1407 // g_assert(process->pid == pid);
1408
1409 if(likely(process != NULL)) {
1410 process->state->s = LTTV_STATE_EXIT;
1411 }
1412 return FALSE;
1413 }
1414
1415 static gboolean process_free(void *hook_data, void *call_data)
1416 {
1417 LttvTracefileState *s = (LttvTracefileState *)call_data;
1418 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
1419 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1420 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1421 guint release_pid;
1422 LttvProcessState *process;
1423
1424 /* PID of the process to release */
1425 release_pid = ltt_event_get_unsigned(e, thf->f1);
1426
1427 g_assert(release_pid != 0);
1428
1429 process = lttv_state_find_process(ts, ANY_CPU, release_pid);
1430
1431 if(likely(process != NULL)) {
1432 /* release_task is happening at kernel level : we can now safely release
1433 * the data structure of the process */
1434 //This test is fun, though, as it may happen that
1435 //at time t : CPU 0 : process_free
1436 //at time t+150ns : CPU 1 : schedule out
1437 //Clearly due to time imprecision, we disable it. (Mathieu)
1438 //If this weird case happen, we have no choice but to put the
1439 //Currently running process on the cpu to 0.
1440 //I re-enable it following time precision fixes. (Mathieu)
1441 //Well, in the case where an process is freed by a process on another CPU
1442 //and still scheduled, it happens that this is the schedchange that will
1443 //drop the last reference count. Do not free it here!
1444 guint num_cpus = ltt_trace_get_num_cpu(ts->parent.t);
1445 guint i;
1446 for(i=0; i< num_cpus; i++) {
1447 //g_assert(process != ts->running_process[i]);
1448 if(process == ts->running_process[i]) {
1449 //ts->running_process[i] = lttv_state_find_process(ts, i, 0);
1450 break;
1451 }
1452 }
1453 //if(i == num_cpus) /* process is not scheduled */
1454 //exit_process(s, process); // do nothing : wait for the schedchange to
1455 //delete the process.
1456 }
1457
1458 return FALSE;
1459 }
1460
1461
1462 static gboolean process_exec(void *hook_data, void *call_data)
1463 {
1464 LttvTracefileState *s = (LttvTracefileState *)call_data;
1465 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
1466 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1467 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1468 //gchar *name;
1469 guint cpu = ltt_tracefile_num(s->parent.tf);
1470 LttvProcessState *process = ts->running_process[cpu];
1471
1472 /* PID of the process to release */
1473 guint64 name_len = ltt_event_field_element_number(e, thf->f1);
1474 //name = ltt_event_get_string(e, thf->f1);
1475 LttField *child = ltt_event_field_element_select(e, thf->f1, 0);
1476 gchar *name_begin =
1477 (gchar*)(ltt_event_data(e)+ltt_event_field_offset(e, child));
1478 gchar *null_term_name = g_new(gchar, name_len+1);
1479 memcpy(null_term_name, name_begin, name_len);
1480 null_term_name[name_len] = '\0';
1481
1482 process->name = g_quark_from_string(null_term_name);
1483 g_free(null_term_name);
1484 return FALSE;
1485 }
1486
1487 static gboolean enum_process_state(void *hook_data, void *call_data)
1488 {
1489 LttvTracefileState *s = (LttvTracefileState *)call_data;
1490 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1491 //It's slow : optimise later by doing this before reading trace.
1492 LttEventType *et = ltt_event_eventtype(e);
1493 //
1494 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1495 guint parent_pid;
1496 guint pid;
1497 gchar * command;
1498 guint cpu = ltt_tracefile_num(s->parent.tf);
1499 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
1500 LttvProcessState *process = ts->running_process[cpu];
1501 LttvProcessState *parent_process;
1502 LttField *f4, *f5, *f6;
1503 GQuark mode, submode, status;
1504
1505 /* PID */
1506 pid = ltt_event_get_unsigned(e, thf->f1);
1507
1508 /* Parent PID */
1509 parent_pid = ltt_event_get_unsigned(e, thf->f2);
1510
1511 /* Command name */
1512 command = ltt_event_get_string(e, thf->f3);
1513
1514 /* mode */
1515 f4 = ltt_eventtype_field_by_name(et, LTT_FIELD_MODE);
1516 mode = ltt_enum_string_get(ltt_field_type(f4),
1517 ltt_event_get_unsigned(e, f4));
1518
1519 /* submode */
1520 f5 = ltt_eventtype_field_by_name(et, LTT_FIELD_SUBMODE);
1521 submode = ltt_enum_string_get(ltt_field_type(f5),
1522 ltt_event_get_unsigned(e, f5));
1523
1524 /* status */
1525 f6 = ltt_eventtype_field_by_name(et, LTT_FIELD_STATUS);
1526 status = ltt_enum_string_get(ltt_field_type(f6),
1527 ltt_event_get_unsigned(e, f6));
1528
1529 /* The process might exist if a process was forked while performing the sate dump. */
1530 process = lttv_state_find_process(ts, ANY_CPU, pid);
1531 if(process == NULL) {
1532 parent_process = lttv_state_find_process(ts, ANY_CPU, parent_pid);
1533 process = lttv_state_create_process(ts, parent_process, cpu,
1534 pid, g_quark_from_string(command),
1535 &s->parent.timestamp);
1536
1537 /* Keep the stack bottom : a running user mode */
1538 #if 0
1539 /* Disabled because of inconsistencies in the current statedump states. */
1540 if(mode == LTTV_STATE_USER_MODE) {
1541 /* Only keep the bottom */
1542 process->execution_stack = g_array_set_size(process->execution_stack, 1);
1543 } else {
1544 /* On top of it : */
1545 LttvExecutionState *es;
1546 es = process->state = &g_array_index(process->execution_stack,
1547 LttvExecutionState, 1);
1548 es->t = mode;
1549 es->s = status;
1550 es->n = submode;
1551 }
1552 #endif //0
1553
1554 /* UNKNOWN STATE */
1555 {
1556 LttvExecutionState *es;
1557 es = process->state = &g_array_index(process->execution_stack,
1558 LttvExecutionState, 1);
1559 es->t = LTTV_STATE_MODE_UNKNOWN;
1560 es->s = LTTV_STATE_UNNAMED;
1561 es->n = LTTV_STATE_SUBMODE_UNKNOWN;
1562 }
1563 } else {
1564 /* The process has already been created :
1565 * Probably was forked while dumping the process state or
1566 * was simply scheduled in prior to get the state dump event.
1567 */
1568 process->ppid = parent_pid;
1569 process->name = g_quark_from_string(command);
1570 /* Don't mess around with the stack, it will eventually become
1571 * ok after the end of state dump. */
1572 }
1573
1574 return FALSE;
1575 }
1576
1577 gint lttv_state_hook_add_event_hooks(void *hook_data, void *call_data)
1578 {
1579 LttvTracesetState *tss = (LttvTracesetState*)(call_data);
1580
1581 lttv_state_add_event_hooks(tss);
1582
1583 return 0;
1584 }
1585
1586 void lttv_state_add_event_hooks(LttvTracesetState *self)
1587 {
1588 LttvTraceset *traceset = self->parent.ts;
1589
1590 guint i, j, k, l, nb_trace, nb_tracefile;
1591
1592 LttvTraceState *ts;
1593
1594 LttvTracefileState *tfs;
1595
1596 GArray *hooks;
1597
1598 LttvTraceHookByFacility *thf;
1599
1600 LttvTraceHook *hook;
1601
1602 LttvAttributeValue val;
1603
1604 gint ret;
1605
1606 nb_trace = lttv_traceset_number(traceset);
1607 for(i = 0 ; i < nb_trace ; i++) {
1608 ts = (LttvTraceState *)self->parent.traces[i];
1609
1610 /* Find the eventtype id for the following events and register the
1611 associated by id hooks. */
1612
1613 hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 15);
1614 hooks = g_array_set_size(hooks, 15);
1615
1616 ret = lttv_trace_find_hook(ts->parent.t,
1617 LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY,
1618 LTT_FIELD_SYSCALL_ID, 0, 0,
1619 syscall_entry, NULL, &g_array_index(hooks, LttvTraceHook, 0));
1620 g_assert(!ret);
1621
1622 ret = lttv_trace_find_hook(ts->parent.t,
1623 LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_EXIT,
1624 0, 0, 0,
1625 syscall_exit, NULL, &g_array_index(hooks, LttvTraceHook, 1));
1626 g_assert(!ret);
1627
1628 ret = lttv_trace_find_hook(ts->parent.t,
1629 LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_ENTRY,
1630 LTT_FIELD_TRAP_ID, 0, 0,
1631 trap_entry, NULL, &g_array_index(hooks, LttvTraceHook, 2));
1632 g_assert(!ret);
1633
1634 ret = lttv_trace_find_hook(ts->parent.t,
1635 LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_EXIT,
1636 0, 0, 0,
1637 trap_exit, NULL, &g_array_index(hooks, LttvTraceHook, 3));
1638 g_assert(!ret);
1639
1640 ret = lttv_trace_find_hook(ts->parent.t,
1641 LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY,
1642 LTT_FIELD_IRQ_ID, 0, 0,
1643 irq_entry, NULL, &g_array_index(hooks, LttvTraceHook, 4));
1644 g_assert(!ret);
1645
1646 ret = lttv_trace_find_hook(ts->parent.t,
1647 LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_EXIT,
1648 0, 0, 0,
1649 irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, 5));
1650 g_assert(!ret);
1651
1652 ret = lttv_trace_find_hook(ts->parent.t,
1653 LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_ENTRY,
1654 LTT_FIELD_SOFT_IRQ_ID, 0, 0,
1655 soft_irq_entry, NULL, &g_array_index(hooks, LttvTraceHook, 6));
1656 g_assert(!ret);
1657
1658 ret = lttv_trace_find_hook(ts->parent.t,
1659 LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_EXIT,
1660 0, 0, 0,
1661 soft_irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, 7));
1662 g_assert(!ret);
1663
1664 ret = lttv_trace_find_hook(ts->parent.t,
1665 LTT_FACILITY_PROCESS, LTT_EVENT_SCHEDCHANGE,
1666 LTT_FIELD_OUT, LTT_FIELD_IN, LTT_FIELD_OUT_STATE,
1667 schedchange, NULL, &g_array_index(hooks, LttvTraceHook, 8));
1668 g_assert(!ret);
1669
1670 ret = lttv_trace_find_hook(ts->parent.t,
1671 LTT_FACILITY_PROCESS, LTT_EVENT_FORK,
1672 LTT_FIELD_PARENT_PID, LTT_FIELD_CHILD_PID, 0,
1673 process_fork, NULL, &g_array_index(hooks, LttvTraceHook, 9));
1674 g_assert(!ret);
1675
1676 ret = lttv_trace_find_hook(ts->parent.t,
1677 LTT_FACILITY_PROCESS, LTT_EVENT_KERNEL_THREAD,
1678 LTT_FIELD_PID, 0, 0,
1679 process_kernel_thread, NULL, &g_array_index(hooks, LttvTraceHook, 10));
1680 g_assert(!ret);
1681
1682 ret = lttv_trace_find_hook(ts->parent.t,
1683 LTT_FACILITY_PROCESS, LTT_EVENT_EXIT,
1684 LTT_FIELD_PID, 0, 0,
1685 process_exit, NULL, &g_array_index(hooks, LttvTraceHook, 11));
1686 g_assert(!ret);
1687
1688 ret = lttv_trace_find_hook(ts->parent.t,
1689 LTT_FACILITY_PROCESS, LTT_EVENT_FREE,
1690 LTT_FIELD_PID, 0, 0,
1691 process_free, NULL, &g_array_index(hooks, LttvTraceHook, 12));
1692 g_assert(!ret);
1693
1694 ret = lttv_trace_find_hook(ts->parent.t,
1695 LTT_FACILITY_FS, LTT_EVENT_EXEC,
1696 LTT_FIELD_FILENAME, 0, 0,
1697 process_exec, NULL, &g_array_index(hooks, LttvTraceHook, 13));
1698 g_assert(!ret);
1699
1700 /* statedump-related hooks */
1701 ret = lttv_trace_find_hook(ts->parent.t,
1702 LTT_FACILITY_STATEDUMP, LTT_EVENT_ENUM_PROCESS_STATE,
1703 LTT_FIELD_PID, LTT_FIELD_PARENT_PID, LTT_FIELD_NAME,
1704 enum_process_state, NULL, &g_array_index(hooks, LttvTraceHook, 14));
1705 g_assert(!ret);
1706
1707
1708 /* Add these hooks to each event_by_id hooks list */
1709
1710 nb_tracefile = ts->parent.tracefiles->len;
1711
1712 for(j = 0 ; j < nb_tracefile ; j++) {
1713 tfs =
1714 LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
1715 LttvTracefileContext*, j));
1716
1717 for(k = 0 ; k < hooks->len ; k++) {
1718 hook = &g_array_index(hooks, LttvTraceHook, k);
1719 for(l=0;l<hook->fac_list->len;l++) {
1720 thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l);
1721 lttv_hooks_add(
1722 lttv_hooks_by_id_find(tfs->parent.event_by_id, thf->id),
1723 thf->h,
1724 thf,
1725 LTTV_PRIO_STATE);
1726 }
1727 }
1728 }
1729 lttv_attribute_find(ts->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
1730 *(val.v_pointer) = hooks;
1731 }
1732 }
1733
1734 gint lttv_state_hook_remove_event_hooks(void *hook_data, void *call_data)
1735 {
1736 LttvTracesetState *tss = (LttvTracesetState*)(call_data);
1737
1738 lttv_state_remove_event_hooks(tss);
1739
1740 return 0;
1741 }
1742
1743 void lttv_state_remove_event_hooks(LttvTracesetState *self)
1744 {
1745 LttvTraceset *traceset = self->parent.ts;
1746
1747 guint i, j, k, l, nb_trace, nb_tracefile;
1748
1749 LttvTraceState *ts;
1750
1751 LttvTracefileState *tfs;
1752
1753 GArray *hooks;
1754
1755 LttvTraceHook *hook;
1756
1757 LttvTraceHookByFacility *thf;
1758
1759 LttvAttributeValue val;
1760
1761 nb_trace = lttv_traceset_number(traceset);
1762 for(i = 0 ; i < nb_trace ; i++) {
1763 ts = LTTV_TRACE_STATE(self->parent.traces[i]);
1764 lttv_attribute_find(ts->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
1765 hooks = *(val.v_pointer);
1766
1767 /* Remove these hooks from each event_by_id hooks list */
1768
1769 nb_tracefile = ts->parent.tracefiles->len;
1770
1771 for(j = 0 ; j < nb_tracefile ; j++) {
1772 tfs =
1773 LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
1774 LttvTracefileContext*, j));
1775
1776 for(k = 0 ; k < hooks->len ; k++) {
1777 hook = &g_array_index(hooks, LttvTraceHook, k);
1778 for(l=0;l<hook->fac_list->len;l++) {
1779 thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l);
1780
1781 lttv_hooks_remove_data(
1782 lttv_hooks_by_id_find(tfs->parent.event_by_id, thf->id),
1783 thf->h,
1784 thf);
1785 }
1786 }
1787 }
1788 for(k = 0 ; k < hooks->len ; k++)
1789 lttv_trace_hook_destroy(&g_array_index(hooks, LttvTraceHook, k));
1790 g_array_free(hooks, TRUE);
1791 }
1792 }
1793
1794 static gboolean state_save_event_hook(void *hook_data, void *call_data)
1795 {
1796 guint *event_count = (guint*)hook_data;
1797
1798 /* Only save at LTTV_STATE_SAVE_INTERVAL */
1799 if(likely((*event_count)++ < LTTV_STATE_SAVE_INTERVAL))
1800 return FALSE;
1801 else
1802 *event_count = 0;
1803
1804 LttvTracefileState *self = (LttvTracefileState *)call_data;
1805
1806 LttvTracefileState *tfcs;
1807
1808 LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
1809
1810 LttEventPosition *ep;
1811
1812 guint i;
1813
1814 LttTracefile *tf;
1815
1816 LttvAttribute *saved_states_tree, *saved_state_tree;
1817
1818 LttvAttributeValue value;
1819
1820 saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
1821 LTTV_STATE_SAVED_STATES);
1822 saved_state_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
1823 value = lttv_attribute_add(saved_states_tree,
1824 lttv_attribute_get_number(saved_states_tree), LTTV_GOBJECT);
1825 *(value.v_gobject) = (GObject *)saved_state_tree;
1826 value = lttv_attribute_add(saved_state_tree, LTTV_STATE_TIME, LTTV_TIME);
1827 *(value.v_time) = self->parent.timestamp;
1828 lttv_state_save(tcs, saved_state_tree);
1829 g_debug("Saving state at time %lu.%lu", self->parent.timestamp.tv_sec,
1830 self->parent.timestamp.tv_nsec);
1831
1832 *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
1833
1834 return FALSE;
1835 }
1836
1837 static gboolean state_save_after_trace_hook(void *hook_data, void *call_data)
1838 {
1839 LttvTraceState *tcs = (LttvTraceState *)(call_data);
1840
1841 *(tcs->max_time_state_recomputed_in_seek) = tcs->parent.time_span.end_time;
1842
1843 return FALSE;
1844 }
1845
1846 #if 0
1847 static gboolean block_start(void *hook_data, void *call_data)
1848 {
1849 LttvTracefileState *self = (LttvTracefileState *)call_data;
1850
1851 LttvTracefileState *tfcs;
1852
1853 LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
1854
1855 LttEventPosition *ep;
1856
1857 guint i, nb_block, nb_event, nb_tracefile;
1858
1859 LttTracefile *tf;
1860
1861 LttvAttribute *saved_states_tree, *saved_state_tree;
1862
1863 LttvAttributeValue value;
1864
1865 ep = ltt_event_position_new();
1866
1867 nb_tracefile = tcs->parent.tracefiles->len;
1868
1869 /* Count the number of events added since the last block end in any
1870 tracefile. */
1871
1872 for(i = 0 ; i < nb_tracefile ; i++) {
1873 tfcs =
1874 LTTV_TRACEFILE_STATE(&g_array_index(tcs->parent.tracefiles,
1875 LttvTracefileContext, i));
1876 ltt_event_position(tfcs->parent.e, ep);
1877 ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
1878 tcs->nb_event += nb_event - tfcs->saved_position;
1879 tfcs->saved_position = nb_event;
1880 }
1881 g_free(ep);
1882
1883 if(tcs->nb_event >= tcs->save_interval) {
1884 saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
1885 LTTV_STATE_SAVED_STATES);
1886 saved_state_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
1887 value = lttv_attribute_add(saved_states_tree,
1888 lttv_attribute_get_number(saved_states_tree), LTTV_GOBJECT);
1889 *(value.v_gobject) = (GObject *)saved_state_tree;
1890 value = lttv_attribute_add(saved_state_tree, LTTV_STATE_TIME, LTTV_TIME);
1891 *(value.v_time) = self->parent.timestamp;
1892 lttv_state_save(tcs, saved_state_tree);
1893 tcs->nb_event = 0;
1894 g_debug("Saving state at time %lu.%lu", self->parent.timestamp.tv_sec,
1895 self->parent.timestamp.tv_nsec);
1896 }
1897 *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
1898 return FALSE;
1899 }
1900 #endif //0
1901
1902 #if 0
1903 static gboolean block_end(void *hook_data, void *call_data)
1904 {
1905 LttvTracefileState *self = (LttvTracefileState *)call_data;
1906
1907 LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
1908
1909 LttTracefile *tf;
1910
1911 LttEventPosition *ep;
1912
1913 guint nb_block, nb_event;
1914
1915 ep = ltt_event_position_new();
1916 ltt_event_position(self->parent.e, ep);
1917 ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
1918 tcs->nb_event += nb_event - self->saved_position + 1;
1919 self->saved_position = 0;
1920 *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
1921 g_free(ep);
1922
1923 return FALSE;
1924 }
1925 #endif //0
1926 #if 0
1927 void lttv_state_save_add_event_hooks(LttvTracesetState *self)
1928 {
1929 LttvTraceset *traceset = self->parent.ts;
1930
1931 guint i, j, nb_trace, nb_tracefile;
1932
1933 LttvTraceState *ts;
1934
1935 LttvTracefileState *tfs;
1936
1937 LttvTraceHook hook_start, hook_end;
1938
1939 nb_trace = lttv_traceset_number(traceset);
1940 for(i = 0 ; i < nb_trace ; i++) {
1941 ts = (LttvTraceState *)self->parent.traces[i];
1942
1943 lttv_trace_find_hook(ts->parent.t, "core","block_start",NULL,
1944 NULL, NULL, block_start, &hook_start);
1945 lttv_trace_find_hook(ts->parent.t, "core","block_end",NULL,
1946 NULL, NULL, block_end, &hook_end);
1947
1948 nb_tracefile = ts->parent.tracefiles->len;
1949
1950 for(j = 0 ; j < nb_tracefile ; j++) {
1951 tfs =
1952 LTTV_TRACEFILE_STATE(&g_array_index(ts->parent.tracefiles,
1953 LttvTracefileContext, j));
1954 lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
1955 hook_start.id), hook_start.h, NULL, LTTV_PRIO_STATE);
1956 lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
1957 hook_end.id), hook_end.h, NULL, LTTV_PRIO_STATE);
1958 }
1959 }
1960 }
1961 #endif //0
1962
1963 void lttv_state_save_add_event_hooks(LttvTracesetState *self)
1964 {
1965 LttvTraceset *traceset = self->parent.ts;
1966
1967 guint i, j, nb_trace, nb_tracefile;
1968
1969 LttvTraceState *ts;
1970
1971 LttvTracefileState *tfs;
1972
1973
1974 nb_trace = lttv_traceset_number(traceset);
1975 for(i = 0 ; i < nb_trace ; i++) {
1976
1977 ts = (LttvTraceState *)self->parent.traces[i];
1978 nb_tracefile = ts->parent.tracefiles->len;
1979
1980 guint *event_count = g_new(guint, 1);
1981 *event_count = 0;
1982
1983 for(j = 0 ; j < nb_tracefile ; j++) {
1984 tfs =
1985 LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
1986 LttvTracefileContext*, j));
1987 lttv_hooks_add(tfs->parent.event,
1988 state_save_event_hook,
1989 event_count,
1990 LTTV_PRIO_STATE);
1991
1992 }
1993 }
1994
1995 lttv_process_traceset_begin(&self->parent,
1996 NULL, NULL, NULL, NULL, NULL);
1997
1998 }
1999
2000 gint lttv_state_save_hook_add_event_hooks(void *hook_data, void *call_data)
2001 {
2002 LttvTracesetState *tss = (LttvTracesetState*)(call_data);
2003
2004 lttv_state_save_add_event_hooks(tss);
2005
2006 return 0;
2007 }
2008
2009
2010 #if 0
2011 void lttv_state_save_remove_event_hooks(LttvTracesetState *self)
2012 {
2013 LttvTraceset *traceset = self->parent.ts;
2014
2015 guint i, j, nb_trace, nb_tracefile;
2016
2017 LttvTraceState *ts;
2018
2019 LttvTracefileState *tfs;
2020
2021 LttvTraceHook hook_start, hook_end;
2022
2023 nb_trace = lttv_traceset_number(traceset);
2024 for(i = 0 ; i < nb_trace ; i++) {
2025 ts = LTTV_TRACE_STATE(self->parent.traces[i]);
2026
2027 lttv_trace_find_hook(ts->parent.t, "core","block_start",NULL,
2028 NULL, NULL, block_start, &hook_start);
2029
2030 lttv_trace_find_hook(ts->parent.t, "core","block_end",NULL,
2031 NULL, NULL, block_end, &hook_end);
2032
2033 nb_tracefile = ts->parent.tracefiles->len;
2034
2035 for(j = 0 ; j < nb_tracefile ; j++) {
2036 tfs =
2037 LTTV_TRACEFILE_STATE(&g_array_index(ts->parent.tracefiles,
2038 LttvTracefileContext, j));
2039 lttv_hooks_remove_data(lttv_hooks_by_id_find(
2040 tfs->parent.event_by_id, hook_start.id), hook_start.h, NULL);
2041 lttv_hooks_remove_data(lttv_hooks_by_id_find(
2042 tfs->parent.event_by_id, hook_end.id), hook_end.h, NULL);
2043 }
2044 }
2045 }
2046 #endif //0
2047
2048 void lttv_state_save_remove_event_hooks(LttvTracesetState *self)
2049 {
2050 LttvTraceset *traceset = self->parent.ts;
2051
2052 guint i, j, nb_trace, nb_tracefile;
2053
2054 LttvTraceState *ts;
2055
2056 LttvTracefileState *tfs;
2057
2058 LttvHooks *after_trace = lttv_hooks_new();
2059
2060 lttv_hooks_add(after_trace,
2061 state_save_after_trace_hook,
2062 NULL,
2063 LTTV_PRIO_STATE);
2064
2065
2066 lttv_process_traceset_end(&self->parent,
2067 NULL, after_trace, NULL, NULL, NULL);
2068
2069 lttv_hooks_destroy(after_trace);
2070
2071 nb_trace = lttv_traceset_number(traceset);
2072 for(i = 0 ; i < nb_trace ; i++) {
2073
2074 ts = (LttvTraceState *)self->parent.traces[i];
2075 nb_tracefile = ts->parent.tracefiles->len;
2076
2077 guint *event_count = NULL;
2078
2079 for(j = 0 ; j < nb_tracefile ; j++) {
2080 tfs =
2081 LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
2082 LttvTracefileContext*, j));
2083 event_count = lttv_hooks_remove(tfs->parent.event,
2084 state_save_event_hook);
2085 }
2086 if(event_count) g_free(event_count);
2087 }
2088 }
2089
2090 gint lttv_state_save_hook_remove_event_hooks(void *hook_data, void *call_data)
2091 {
2092 LttvTracesetState *tss = (LttvTracesetState*)(call_data);
2093
2094 lttv_state_save_remove_event_hooks(tss);
2095
2096 return 0;
2097 }
2098
2099 void lttv_state_traceset_seek_time_closest(LttvTracesetState *self, LttTime t)
2100 {
2101 LttvTraceset *traceset = self->parent.ts;
2102
2103 guint i, nb_trace;
2104
2105 int min_pos, mid_pos, max_pos;
2106
2107 guint call_rest = 0;
2108
2109 LttvTraceState *tcs;
2110
2111 LttvAttributeValue value;
2112
2113 LttvAttributeType type;
2114
2115 LttvAttributeName name;
2116
2117 LttvAttribute *saved_states_tree, *saved_state_tree, *closest_tree;
2118
2119 //g_tree_destroy(self->parent.pqueue);
2120 //self->parent.pqueue = g_tree_new(compare_tracefile);
2121
2122 g_info("Entering seek_time_closest for time %lu.%lu", t.tv_sec, t.tv_nsec);
2123
2124 nb_trace = lttv_traceset_number(traceset);
2125 for(i = 0 ; i < nb_trace ; i++) {
2126 tcs = (LttvTraceState *)self->parent.traces[i];
2127
2128 if(ltt_time_compare(t, *(tcs->max_time_state_recomputed_in_seek)) < 0) {
2129 saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
2130 LTTV_STATE_SAVED_STATES);
2131 min_pos = -1;
2132
2133 if(saved_states_tree) {
2134 max_pos = lttv_attribute_get_number(saved_states_tree) - 1;
2135 mid_pos = max_pos / 2;
2136 while(min_pos < max_pos) {
2137 type = lttv_attribute_get(saved_states_tree, mid_pos, &name, &value);
2138 g_assert(type == LTTV_GOBJECT);
2139 saved_state_tree = *((LttvAttribute **)(value.v_gobject));
2140 type = lttv_attribute_get_by_name(saved_state_tree, LTTV_STATE_TIME,
2141 &value);
2142 g_assert(type == LTTV_TIME);
2143 if(ltt_time_compare(*(value.v_time), t) < 0) {
2144 min_pos = mid_pos;
2145 closest_tree = saved_state_tree;
2146 }
2147 else max_pos = mid_pos - 1;
2148
2149 mid_pos = (min_pos + max_pos + 1) / 2;
2150 }
2151 }
2152
2153 /* restore the closest earlier saved state */
2154 if(min_pos != -1) {
2155 lttv_state_restore(tcs, closest_tree);
2156 call_rest = 1;
2157 }
2158
2159 /* There is no saved state, yet we want to have it. Restart at T0 */
2160 else {
2161 restore_init_state(tcs);
2162 lttv_process_trace_seek_time(&(tcs->parent), ltt_time_zero);
2163 }
2164 }
2165 /* We want to seek quickly without restoring/updating the state */
2166 else {
2167 restore_init_state(tcs);
2168 lttv_process_trace_seek_time(&(tcs->parent), t);
2169 }
2170 }
2171 if(!call_rest) g_info("NOT Calling restore");
2172 }
2173
2174
2175 static void
2176 traceset_state_instance_init (GTypeInstance *instance, gpointer g_class)
2177 {
2178 }
2179
2180
2181 static void
2182 traceset_state_finalize (LttvTracesetState *self)
2183 {
2184 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
2185 finalize(G_OBJECT(self));
2186 }
2187
2188
2189 static void
2190 traceset_state_class_init (LttvTracesetContextClass *klass)
2191 {
2192 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
2193
2194 gobject_class->finalize = (void (*)(GObject *self)) traceset_state_finalize;
2195 klass->init = (void (*)(LttvTracesetContext *self, LttvTraceset *ts))init;
2196 klass->fini = (void (*)(LttvTracesetContext *self))fini;
2197 klass->new_traceset_context = new_traceset_context;
2198 klass->new_trace_context = new_trace_context;
2199 klass->new_tracefile_context = new_tracefile_context;
2200 }
2201
2202
2203 GType
2204 lttv_traceset_state_get_type(void)
2205 {
2206 static GType type = 0;
2207 if (type == 0) {
2208 static const GTypeInfo info = {
2209 sizeof (LttvTracesetStateClass),
2210 NULL, /* base_init */
2211 NULL, /* base_finalize */
2212 (GClassInitFunc) traceset_state_class_init, /* class_init */
2213 NULL, /* class_finalize */
2214 NULL, /* class_data */
2215 sizeof (LttvTracesetState),
2216 0, /* n_preallocs */
2217 (GInstanceInitFunc) traceset_state_instance_init, /* instance_init */
2218 NULL /* value handling */
2219 };
2220
2221 type = g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE, "LttvTracesetStateType",
2222 &info, 0);
2223 }
2224 return type;
2225 }
2226
2227
2228 static void
2229 trace_state_instance_init (GTypeInstance *instance, gpointer g_class)
2230 {
2231 }
2232
2233
2234 static void
2235 trace_state_finalize (LttvTraceState *self)
2236 {
2237 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_CONTEXT_TYPE))->
2238 finalize(G_OBJECT(self));
2239 }
2240
2241
2242 static void
2243 trace_state_class_init (LttvTraceStateClass *klass)
2244 {
2245 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
2246
2247 gobject_class->finalize = (void (*)(GObject *self)) trace_state_finalize;
2248 klass->state_save = state_save;
2249 klass->state_restore = state_restore;
2250 klass->state_saved_free = state_saved_free;
2251 }
2252
2253
2254 GType
2255 lttv_trace_state_get_type(void)
2256 {
2257 static GType type = 0;
2258 if (type == 0) {
2259 static const GTypeInfo info = {
2260 sizeof (LttvTraceStateClass),
2261 NULL, /* base_init */
2262 NULL, /* base_finalize */
2263 (GClassInitFunc) trace_state_class_init, /* class_init */
2264 NULL, /* class_finalize */
2265 NULL, /* class_data */
2266 sizeof (LttvTraceState),
2267 0, /* n_preallocs */
2268 (GInstanceInitFunc) trace_state_instance_init, /* instance_init */
2269 NULL /* value handling */
2270 };
2271
2272 type = g_type_register_static (LTTV_TRACE_CONTEXT_TYPE,
2273 "LttvTraceStateType", &info, 0);
2274 }
2275 return type;
2276 }
2277
2278
2279 static void
2280 tracefile_state_instance_init (GTypeInstance *instance, gpointer g_class)
2281 {
2282 }
2283
2284
2285 static void
2286 tracefile_state_finalize (LttvTracefileState *self)
2287 {
2288 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_CONTEXT_TYPE))->
2289 finalize(G_OBJECT(self));
2290 }
2291
2292
2293 static void
2294 tracefile_state_class_init (LttvTracefileStateClass *klass)
2295 {
2296 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
2297
2298 gobject_class->finalize = (void (*)(GObject *self)) tracefile_state_finalize;
2299 }
2300
2301
2302 GType
2303 lttv_tracefile_state_get_type(void)
2304 {
2305 static GType type = 0;
2306 if (type == 0) {
2307 static const GTypeInfo info = {
2308 sizeof (LttvTracefileStateClass),
2309 NULL, /* base_init */
2310 NULL, /* base_finalize */
2311 (GClassInitFunc) tracefile_state_class_init, /* class_init */
2312 NULL, /* class_finalize */
2313 NULL, /* class_data */
2314 sizeof (LttvTracefileState),
2315 0, /* n_preallocs */
2316 (GInstanceInitFunc) tracefile_state_instance_init, /* instance_init */
2317 NULL /* value handling */
2318 };
2319
2320 type = g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE,
2321 "LttvTracefileStateType", &info, 0);
2322 }
2323 return type;
2324 }
2325
2326
2327 static void module_init()
2328 {
2329 LTTV_STATE_UNNAMED = g_quark_from_string("unnamed");
2330 LTTV_STATE_MODE_UNKNOWN = g_quark_from_string("MODE_UNKNOWN");
2331 LTTV_STATE_USER_MODE = g_quark_from_string("USER_MODE");
2332 LTTV_STATE_SYSCALL = g_quark_from_string("SYSCALL");
2333 LTTV_STATE_TRAP = g_quark_from_string("TRAP");
2334 LTTV_STATE_IRQ = g_quark_from_string("IRQ");
2335 LTTV_STATE_SOFT_IRQ = g_quark_from_string("SOFTIRQ");
2336 LTTV_STATE_SUBMODE_UNKNOWN = g_quark_from_string("UNKNOWN");
2337 LTTV_STATE_SUBMODE_NONE = g_quark_from_string("NONE");
2338 LTTV_STATE_WAIT_FORK = g_quark_from_string("WAIT_FORK");
2339 LTTV_STATE_WAIT_CPU = g_quark_from_string("WAIT_CPU");
2340 LTTV_STATE_EXIT = g_quark_from_string("EXIT");
2341 LTTV_STATE_ZOMBIE = g_quark_from_string("ZOMBIE");
2342 LTTV_STATE_WAIT = g_quark_from_string("WAIT");
2343 LTTV_STATE_RUN = g_quark_from_string("RUN");
2344 LTTV_STATE_DEAD = g_quark_from_string("DEAD");
2345 LTTV_STATE_TRACEFILES = g_quark_from_string("tracefiles");
2346 LTTV_STATE_PROCESSES = g_quark_from_string("processes");
2347 LTTV_STATE_PROCESS = g_quark_from_string("process");
2348 LTTV_STATE_RUNNING_PROCESS = g_quark_from_string("running_process");
2349 LTTV_STATE_EVENT = g_quark_from_string("event");
2350 LTTV_STATE_SAVED_STATES = g_quark_from_string("saved states");
2351 LTTV_STATE_SAVED_STATES_TIME = g_quark_from_string("saved states time");
2352 LTTV_STATE_TIME = g_quark_from_string("time");
2353 LTTV_STATE_HOOKS = g_quark_from_string("saved state hooks");
2354 LTTV_STATE_NAME_TABLES = g_quark_from_string("name tables");
2355 LTTV_STATE_TRACE_STATE_USE_COUNT =
2356 g_quark_from_string("trace_state_use_count");
2357
2358
2359 LTT_FACILITY_KERNEL = g_quark_from_string("kernel");
2360 LTT_FACILITY_KERNEL_ARCH = g_quark_from_string("kernel_arch");
2361 LTT_FACILITY_PROCESS = g_quark_from_string("process");
2362 LTT_FACILITY_FS = g_quark_from_string("fs");
2363 LTT_FACILITY_STATEDUMP = g_quark_from_string("statedump");
2364
2365
2366 LTT_EVENT_SYSCALL_ENTRY = g_quark_from_string("syscall_entry");
2367 LTT_EVENT_SYSCALL_EXIT = g_quark_from_string("syscall_exit");
2368 LTT_EVENT_TRAP_ENTRY = g_quark_from_string("trap_entry");
2369 LTT_EVENT_TRAP_EXIT = g_quark_from_string("trap_exit");
2370 LTT_EVENT_IRQ_ENTRY = g_quark_from_string("irq_entry");
2371 LTT_EVENT_IRQ_EXIT = g_quark_from_string("irq_exit");
2372 LTT_EVENT_SOFT_IRQ_ENTRY = g_quark_from_string("soft_irq_entry");
2373 LTT_EVENT_SOFT_IRQ_EXIT = g_quark_from_string("soft_irq_exit");
2374 LTT_EVENT_SCHEDCHANGE = g_quark_from_string("schedchange");
2375 LTT_EVENT_FORK = g_quark_from_string("fork");
2376 LTT_EVENT_KERNEL_THREAD = g_quark_from_string("kernel_thread");
2377 LTT_EVENT_EXIT = g_quark_from_string("exit");
2378 LTT_EVENT_FREE = g_quark_from_string("free");
2379 LTT_EVENT_EXEC = g_quark_from_string("exec");
2380 LTT_EVENT_ENUM_PROCESS_STATE = g_quark_from_string("enumerate_process_state");
2381
2382
2383 LTT_FIELD_SYSCALL_ID = g_quark_from_string("syscall_id");
2384 LTT_FIELD_TRAP_ID = g_quark_from_string("trap_id");
2385 LTT_FIELD_IRQ_ID = g_quark_from_string("irq_id");
2386 LTT_FIELD_SOFT_IRQ_ID = g_quark_from_string("softirq_id");
2387 LTT_FIELD_OUT = g_quark_from_string("out");
2388 LTT_FIELD_IN = g_quark_from_string("in");
2389 LTT_FIELD_OUT_STATE = g_quark_from_string("out_state");
2390 LTT_FIELD_PARENT_PID = g_quark_from_string("parent_pid");
2391 LTT_FIELD_CHILD_PID = g_quark_from_string("child_pid");
2392 LTT_FIELD_PID = g_quark_from_string("pid");
2393 LTT_FIELD_FILENAME = g_quark_from_string("filename");
2394 LTT_FIELD_NAME = g_quark_from_string("name");
2395 LTT_FIELD_MODE = g_quark_from_string("mode");
2396 LTT_FIELD_SUBMODE = g_quark_from_string("submode");
2397 LTT_FIELD_STATUS = g_quark_from_string("status");
2398
2399 }
2400
2401 static void module_destroy()
2402 {
2403 }
2404
2405
2406 LTTV_MODULE("state", "State computation", \
2407 "Update the system state, possibly saving it at intervals", \
2408 module_init, module_destroy)
2409
2410
2411
LTTng 2.x Viewer (LTTV)
This page took 0.0865629999999999 seconds and 5 git commands to generate.