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