projects / lttv.git / blob
? search:


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