projects / lttv.git / blob
? search:


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