git-svn-id: http://ltt.polymtl.ca/svn@213 04897980-b3bd-0310-b5e0-8ef037075253
[lttv.git] / ltt / branches / poly / lttv / state.c
CommitLineData
dc877563 1
2#include <lttv/state.h>
ba576a78 3#include <ltt/facility.h>
4#include <ltt/trace.h>
dc877563 5
ffd54a90 6LttvInterruptType
7 LTTV_STATE_USER_MODE,
8 LTTV_STATE_SYSCALL,
9 LTTV_STATE_TRAP,
10 LTTV_STATE_IRQ;
11
12
13LttvProcessStatus
14 LTTV_STATE_UNNAMED,
15 LTTV_STATE_WAIT_FORK,
16 LTTV_STATE_WAIT_CPU,
17 LTTV_STATE_EXIT,
18 LTTV_STATE_WAIT,
19 LTTV_STATE_RUN;
20
ba576a78 21static GQuark
22 LTTV_STATE_HOOKS;
23
24void remove_all_processes(GHashTable *processes);
25
3d27549e 26LttvProcessState *create_process(LttvTracefileState *tfs,
27 LttvProcessState *parent, guint pid);
dc877563 28
29static void
30init(LttvTracesetState *self, LttvTraceset *ts)
31{
32 guint i, j, nb_trace, nb_tracefile;
33
ffd54a90 34 LttvTraceContext *tc;
dc877563 35
ffd54a90 36 LttvTraceState *tcs;
37
38 LttvTracefileContext *tfc;
dc877563 39
ffd54a90 40 LttvTracefileState *tfcs;
3d27549e 41
42 LttTime timestamp = {0,0};
ffd54a90 43
44 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek_parent(LTTV_TRACESET_STATE_GET_CLASS(self)))->init((LttvTracesetContext *)self, ts);
dc877563 45
46 nb_trace = lttv_traceset_number(ts);
47 for(i = 0 ; i < nb_trace ; i++) {
ffd54a90 48 tcs = (LttvTraceState *)tc = (LTTV_TRACESET_CONTEXT(self)->traces[i]);
49 tcs->processes = g_hash_table_new(g_direct_hash, g_direct_equal);
dc877563 50
51 nb_tracefile = ltt_trace_control_tracefile_number(tc->t);
52 for(j = 0 ; j < nb_tracefile ; j++) {
ffd54a90 53 tfcs = (LttvTracefileState *)tfc = tc->control_tracefiles[j];
3d27549e 54 tfc->timestamp = timestamp;
55 tfcs->process = create_process(tfcs, NULL,0);
dc877563 56 }
57
58 nb_tracefile = ltt_trace_per_cpu_tracefile_number(tc->t);
59 for(j = 0 ; j < nb_tracefile ; j++) {
ffd54a90 60 tfcs = (LttvTracefileState *)tfc = tc->per_cpu_tracefiles[j];
3d27549e 61 tfc->timestamp = timestamp;
62 tfcs->process = create_process(tfcs, NULL,0);
dc877563 63 }
64 }
65}
66
67
68static void
69fini(LttvTracesetState *self)
70{
71 guint i, j, nb_trace, nb_tracefile;
72
ffd54a90 73 LttvTraceState *tcs;
dc877563 74
ffd54a90 75 LttvTracefileState *tfcs;
dc877563 76
ffd54a90 77 nb_trace = lttv_traceset_number(LTTV_TRACESET_CONTEXT(self)->ts);
dc877563 78 for(i = 0 ; i < nb_trace ; i++) {
ffd54a90 79 tcs = (LttvTraceState *)(LTTV_TRACESET_CONTEXT(self)->traces[i]);
80 remove_all_processes(tcs->processes);
81 g_hash_table_destroy(tcs->processes);
dc877563 82 }
ffd54a90 83 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek_parent(LTTV_TRACESET_STATE_GET_CLASS(self)))->fini((LttvTracesetContext *)self);
dc877563 84}
85
86
c432246e 87static LttvTracesetContext *
dc877563 88new_traceset_context(LttvTracesetContext *self)
89{
ffd54a90 90 return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE, NULL));
dc877563 91}
92
93
c432246e 94static LttvTraceContext *
dc877563 95new_trace_context(LttvTracesetContext *self)
96{
ffd54a90 97 return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE, NULL));
dc877563 98}
99
100
c432246e 101static LttvTracefileContext *
dc877563 102new_tracefile_context(LttvTracesetContext *self)
103{
ffd54a90 104 return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE, NULL));
105}
106
107
108static void
109traceset_state_instance_init (GTypeInstance *instance, gpointer g_class)
110{
111}
112
113
114static void
c6bc9cb9 115traceset_state_finalize (LttvTracesetState *self)
ffd54a90 116{
c6bc9cb9 117 G_OBJECT_CLASS(g_type_class_peek_parent(g_type_class_peek_parent(LTTV_TRACESET_STATE_GET_CLASS(self))))->finalize(G_OBJECT(self));
ffd54a90 118}
119
120
121static void
122traceset_state_class_init (LttvTracesetContextClass *klass)
123{
124 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
125
126 gobject_class->finalize = (void (*)(GObject *self)) traceset_state_finalize;
127 klass->init = (void (*)(LttvTracesetContext *self, LttvTraceset *ts))init;
128 klass->fini = (void (*)(LttvTracesetContext *self))fini;
129 klass->new_traceset_context = new_traceset_context;
130 klass->new_trace_context = new_trace_context;
131 klass->new_tracefile_context = new_tracefile_context;
dc877563 132}
133
134
135GType
136lttv_traceset_state_get_type(void)
137{
138 static GType type = 0;
139 if (type == 0) {
140 static const GTypeInfo info = {
141 sizeof (LttvTracesetStateClass),
142 NULL, /* base_init */
143 NULL, /* base_finalize */
ffd54a90 144 (GClassInitFunc) traceset_state_class_init, /* class_init */
dc877563 145 NULL, /* class_finalize */
146 NULL, /* class_data */
147 sizeof (LttvTracesetContext),
148 0, /* n_preallocs */
ffd54a90 149 (GInstanceInitFunc) traceset_state_instance_init /* instance_init */
dc877563 150 };
151
152 type = g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE, "LttvTracesetStateType",
153 &info, 0);
154 }
155 return type;
156}
157
158
159static void
ffd54a90 160trace_state_instance_init (GTypeInstance *instance, gpointer g_class)
dc877563 161{
162}
163
164
165static void
c6bc9cb9 166trace_state_finalize (LttvTraceState *self)
dc877563 167{
c6bc9cb9 168 G_OBJECT_CLASS(g_type_class_peek_parent(g_type_class_peek_parent(LTTV_TRACE_STATE_GET_CLASS(self))))->finalize(G_OBJECT(self));
dc877563 169}
170
171
172static void
ffd54a90 173trace_state_class_init (LttvTraceContextClass *klass)
dc877563 174{
175 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
176
ffd54a90 177 gobject_class->finalize = (void (*)(GObject *self)) trace_state_finalize;
dc877563 178}
179
180
181GType
182lttv_trace_state_get_type(void)
183{
184 static GType type = 0;
185 if (type == 0) {
186 static const GTypeInfo info = {
187 sizeof (LttvTraceStateClass),
188 NULL, /* base_init */
189 NULL, /* base_finalize */
ffd54a90 190 (GClassInitFunc) trace_state_class_init, /* class_init */
dc877563 191 NULL, /* class_finalize */
192 NULL, /* class_data */
c6bc9cb9 193 sizeof (LttvTraceState),
dc877563 194 0, /* n_preallocs */
ffd54a90 195 (GInstanceInitFunc) trace_state_instance_init /* instance_init */
dc877563 196 };
197
198 type = g_type_register_static (LTTV_TRACE_CONTEXT_TYPE,
199 "LttvTraceStateType", &info, 0);
200 }
201 return type;
202}
203
204
205static void
ffd54a90 206tracefile_state_instance_init (GTypeInstance *instance, gpointer g_class)
dc877563 207{
208}
209
210
211static void
ffd54a90 212tracefile_state_finalize (LttvTracefileState *self)
dc877563 213{
c6bc9cb9 214 G_OBJECT_CLASS(g_type_class_peek_parent(g_type_class_peek_parent(LTTV_TRACEFILE_STATE_GET_CLASS(self))))->finalize(G_OBJECT(self));
dc877563 215}
216
217
218static void
ffd54a90 219tracefile_state_class_init (LttvTracefileStateClass *klass)
dc877563 220{
221 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
222
ffd54a90 223 gobject_class->finalize = (void (*)(GObject *self)) tracefile_state_finalize;
dc877563 224}
225
226
227GType
228lttv_tracefile_state_get_type(void)
229{
230 static GType type = 0;
231 if (type == 0) {
232 static const GTypeInfo info = {
233 sizeof (LttvTracefileStateClass),
234 NULL, /* base_init */
235 NULL, /* base_finalize */
ffd54a90 236 (GClassInitFunc) tracefile_state_class_init, /* class_init */
dc877563 237 NULL, /* class_finalize */
238 NULL, /* class_data */
239 sizeof (LttvTracefileState),
240 0, /* n_preallocs */
ffd54a90 241 (GInstanceInitFunc) tracefile_state_instance_init /* instance_init */
dc877563 242 };
243
244 type = g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE,
245 "LttvTracefileStateType", &info, 0);
246 }
247 return type;
248}
249
250
dc877563 251struct HookData {
252 LttField *f1;
253 LttField *f2;
254 LttField *f3;
ffd54a90 255};
dc877563 256
257
258struct HookId {
259 LttvHook h;
260 guint id;
261 void *hook_data;
262 gboolean free_hook_data;
ffd54a90 263};
dc877563 264
265
ffd54a90 266static void push_state(LttvTracefileState *tfs, LttvInterruptType t,
267 guint state_id)
dc877563 268{
ffd54a90 269 LttvInterruptState *intr;
dc877563 270
271 LttvProcessState *process = tfs->process;
272
273 guint depth = process->interrupt_stack->len;
274
275 g_array_set_size(process->interrupt_stack, depth + 1);
276 intr = &g_array_index(process->interrupt_stack, LttvInterruptState, depth);
277 intr->t = t;
278 intr->n = state_id;
ffd54a90 279 intr->entry = intr->last_change = LTTV_TRACEFILE_CONTEXT(tfs)->timestamp;
dc877563 280 intr->s = process->state->s;
c432246e 281 process->state = intr;
dc877563 282}
283
284
ffd54a90 285static void pop_state(LttvTracefileState *tfs, LttvInterruptType t)
dc877563 286{
287 LttvProcessState *process = tfs->process;
288
289 guint depth = process->interrupt_stack->len - 1;
290
3d27549e 291 // g_assert(process->state->t == t);
292 if(process->state->t != t){
293 g_warning("Different interrupt type: ignore it\n");
294 return;
295 }
dc877563 296 g_array_remove_index(process->interrupt_stack, depth);
297 depth--;
298 process->state = &g_array_index(process->interrupt_stack, LttvInterruptState,
299 depth);
300}
301
302
ffd54a90 303LttvProcessState *create_process(LttvTracefileState *tfs,
304 LttvProcessState *parent, guint pid)
dc877563 305{
306 LttvProcessState *process = g_new(LttvProcessState, 1);
307
308 LttvInterruptState *intr;
309
ffd54a90 310 LttvTraceContext *tc;
311
ba576a78 312 LttvTraceState *tcs;
313
314 LttvTracefileContext *tfc = LTTV_TRACEFILE_CONTEXT(tfs);
ffd54a90 315
ba576a78 316 tcs = (LttvTraceState *)tc = tfc->t_context;
ffd54a90 317
318 g_hash_table_insert(tcs->processes, GUINT_TO_POINTER(pid), process);
dc877563 319 process->pid = pid;
ba576a78 320 process->birth = tfc->timestamp;
dc877563 321 process->name = LTTV_STATE_UNNAMED;
322 process->interrupt_stack = g_array_new(FALSE, FALSE,
323 sizeof(LttvInterruptState));
324 g_array_set_size(process->interrupt_stack, 1);
ffd54a90 325 intr = process->state = &g_array_index(process->interrupt_stack,
326 LttvInterruptState, 0);
ba576a78 327 intr->t = LTTV_STATE_USER_MODE;
dc877563 328 intr->n = 0;
ba576a78 329 intr->entry = tfc->timestamp;
330 intr->last_change = tfc->timestamp;
dc877563 331 intr->s = LTTV_STATE_WAIT_FORK;
cbe7c836 332
333 return process;
dc877563 334}
335
336
ba576a78 337LttvProcessState *find_process(LttvTracefileState *tfs, guint pid)
dc877563 338{
ba576a78 339 LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
340 LttvProcessState *process = g_hash_table_lookup(ts->processes,
341 GUINT_TO_POINTER(pid));
dc877563 342 if(process == NULL) process = create_process(tfs, NULL, pid);
343 return process;
344}
345
346
ba576a78 347void exit_process(LttvTracefileState *tfs, LttvProcessState *process)
dc877563 348{
ba576a78 349 LttvTraceState *ts = LTTV_TRACE_STATE(tfs->parent.t_context);
350
351 g_hash_table_remove(ts->processes, GUINT_TO_POINTER(process->pid));
dc877563 352 g_array_free(process->interrupt_stack, TRUE);
353 g_free(process);
354}
355
356
357void free_process_state(gpointer key, gpointer value, gpointer user_data)
358{
359 g_array_free(((LttvProcessState *)value)->interrupt_stack, TRUE);
360 g_free(value);
361}
362
363
364void remove_all_processes(GHashTable *processes)
365{
366 g_hash_table_foreach(processes, free_process_state, NULL);
367}
368
369
370gboolean syscall_entry(void *hook_data, void *call_data)
371{
372 LttField *f = (LttField *)hook_data;
373
ba576a78 374 LttvTracefileState *s = (LttvTracefileState *)call_data;
dc877563 375
ba576a78 376 push_state(s, LTTV_STATE_SYSCALL, ltt_event_get_unsigned(
377 LTTV_TRACEFILE_CONTEXT(s)->e, f));
dc877563 378 return FALSE;
379}
380
381
382gboolean syscall_exit(void *hook_data, void *call_data)
383{
ba576a78 384 LttvTracefileState *s = (LttvTracefileState *)call_data;
dc877563 385
ffd54a90 386 pop_state(s, LTTV_STATE_SYSCALL);
dc877563 387 return FALSE;
388}
389
390
391gboolean trap_entry(void *hook_data, void *call_data)
392{
393 LttField *f = (LttField *)hook_data;
394
ba576a78 395 LttvTracefileState *s = (LttvTracefileState *)call_data;
dc877563 396
ba576a78 397 push_state(s, LTTV_STATE_TRAP, ltt_event_get_unsigned(s->parent.e, f));
dc877563 398 return FALSE;
399}
400
401
402gboolean trap_exit(void *hook_data, void *call_data)
403{
ba576a78 404 LttvTracefileState *s = (LttvTracefileState *)call_data;
dc877563 405
ffd54a90 406 pop_state(s, LTTV_STATE_TRAP);
dc877563 407 return FALSE;
408}
409
410
411gboolean irq_entry(void *hook_data, void *call_data)
412{
413 LttField *f = (LttField *)hook_data;
414
ba576a78 415 LttvTracefileState *s = (LttvTracefileState *)call_data;
dc877563 416
417 /* Do something with the info about being in user or system mode when int? */
ba576a78 418 push_state(s, LTTV_STATE_IRQ, ltt_event_get_unsigned(s->parent.e, f));
dc877563 419 return FALSE;
420}
421
422
423gboolean irq_exit(void *hook_data, void *call_data)
424{
ba576a78 425 LttvTracefileState *s = (LttvTracefileState *)call_data;
dc877563 426
ffd54a90 427 pop_state(s, LTTV_STATE_IRQ);
dc877563 428 return FALSE;
429}
430
431
432gboolean schedchange(void *hook_data, void *call_data)
433{
434 struct HookData *h = (struct HookData *)hook_data;
435
ba576a78 436 LttvTracefileState *s = (LttvTracefileState *)call_data;
dc877563 437
438 guint pid_in, pid_out, state_out;
439
3d27549e 440 pid_in = ltt_event_get_unsigned(s->parent.e, h->f1);
441 pid_out = ltt_event_get_unsigned(s->parent.e, h->f2);
442 state_out = ltt_event_get_unsigned(s->parent.e, h->f3);
dc877563 443 if(s->process != NULL) {
ffd54a90 444 if(state_out == 0) s->process->state->s = LTTV_STATE_WAIT_CPU;
445 else if(s->process->state->s == LTTV_STATE_EXIT)
ba576a78 446 exit_process(s, s->process);
ffd54a90 447 else s->process->state->s = LTTV_STATE_WAIT;
3d27549e 448
449 if(s->process->pid == 0)
450 s->process->pid == pid_out;
dc877563 451 }
ba576a78 452 s->process = find_process(s, pid_in);
ffd54a90 453 s->process->state->s = LTTV_STATE_RUN;
dc877563 454 return FALSE;
455}
456
457
458gboolean process_fork(void *hook_data, void *call_data)
459{
460 LttField *f = (LttField *)hook_data;
461
ba576a78 462 LttvTracefileState *s = (LttvTracefileState *)call_data;
dc877563 463
464 guint child_pid;
465
3d27549e 466 child_pid = ltt_event_get_unsigned(s->parent.e, f);
ba576a78 467 create_process(s, s->process, child_pid);
dc877563 468 return FALSE;
469}
470
471
472gboolean process_exit(void *hook_data, void *call_data)
473{
ba576a78 474 LttvTracefileState *s = (LttvTracefileState *)call_data;
dc877563 475
476 if(s->process != NULL) {
ffd54a90 477 s->process->state->s = LTTV_STATE_EXIT;
dc877563 478 }
479 return FALSE;
480}
481
482
483static LttField *
484find_field(LttEventType *et, const char *field)
485{
486 LttType *t;
487
488 LttField *f;
489
490 guint i, nb;
491
492 char *name;
493
494 if(field == NULL) return NULL;
495
496 f = ltt_eventtype_field(et);
497 t = ltt_eventtype_type(et);
498 g_assert(ltt_type_class(t) == LTT_STRUCT);
499 nb = ltt_type_member_number(t);
500 for(i = 0 ; i < nb ; i++) {
501 ltt_type_member_type(t, i, &name);
502 if(strcmp(name, field) == 0) break;
503 }
504 g_assert(i < nb);
505 return ltt_field_member(f, i);
506}
507
508
ba576a78 509static struct HookId
510find_hook(LttTrace *t, char *facility, char *event,
511 char *field1, char *field2, char *field3, LttvHook h)
dc877563 512{
513 LttFacility *f;
514
515 LttEventType *et;
516
517 guint nb, pos, i;
518
519 struct HookId hook_id;
520
521 struct HookData hook_data, *phook_data;
522
523 char *name;
524
525 nb = ltt_trace_facility_find(t, facility, &pos);
526 if(nb < 1) g_error("No %s facility", facility);
ba576a78 527 f = ltt_trace_facility_get(t, pos);
528 et = ltt_facility_eventtype_get_by_name(f, event);
dc877563 529 if(et == NULL) g_error("Event %s does not exist", event);
530
c432246e 531 hook_id.id = ltt_eventtype_id(et);
dc877563 532 hook_id.h = h;
533 hook_id.free_hook_data = FALSE;
534 hook_data.f1 = find_field(et, field1);
535 hook_data.f2 = find_field(et, field2);
536 hook_data.f3 = find_field(et, field3);
ba576a78 537 if(hook_data.f1 == NULL) hook_id.hook_data = NULL;
538 else if(hook_data.f2 == NULL) hook_id.hook_data = hook_data.f1;
dc877563 539 else {
540 phook_data = g_new(struct HookData, 1);
541 *phook_data = hook_data;
542 hook_id.hook_data = phook_data;
543 hook_id.free_hook_data = TRUE;
544 }
545 return hook_id;
546}
547
548
549lttv_state_add_event_hooks(LttvTracesetState *self)
550{
ba576a78 551 LttvTraceset *traceset = self->parent.ts;
dc877563 552
ba576a78 553 guint i, j, k, nb_trace, nb_control, nb_per_cpu, nb_tracefile;
dc877563 554
555 LttFacility *f;
556
557 LttEventType *et;
558
ba576a78 559 LttvTraceState *ts;
dc877563 560
ba576a78 561 LttvTracefileState *tfs;
dc877563 562
563 void *hook_data;
564
565 GArray *hooks;
566
567 struct HookId hook_id;
568
569 LttvAttributeValue val;
570
ba576a78 571 nb_trace = lttv_traceset_number(traceset);
dc877563 572 for(i = 0 ; i < nb_trace ; i++) {
ba576a78 573 ts = (LttvTraceState *)self->parent.traces[i];
dc877563 574
575 /* Find the eventtype id for the following events and register the
576 associated by id hooks. */
577
ba576a78 578 hooks = g_array_new(FALSE, FALSE, sizeof(struct HookId));
cbe7c836 579 hook_id = find_hook(ts->parent.t, "core","syscall_entry","syscall_id",
580 NULL, NULL, syscall_entry);
581 g_array_append_val(hooks, hook_id);
582
583 hook_id = find_hook(ts->parent.t, "core", "syscall_exit",
584 NULL, NULL, NULL, syscall_exit);
585 g_array_append_val(hooks, hook_id);
586
587 hook_id = find_hook(ts->parent.t, "core", "trap_entry", "trap_id",
588 NULL, NULL, trap_entry);
589 g_array_append_val(hooks, hook_id);
590
591 hook_id = find_hook(ts->parent.t, "core", "trap_exit", NULL, NULL,
592 NULL, trap_exit);
593 g_array_append_val(hooks, hook_id);
594
595 hook_id = find_hook(ts->parent.t, "core", "irq_entry", "irq_id",
596 NULL, NULL, irq_entry);
597 g_array_append_val(hooks, hook_id);
598
599 hook_id = find_hook(ts->parent.t, "core", "irq_exit", NULL, NULL,
600 NULL, irq_exit);
601 g_array_append_val(hooks, hook_id);
602
603 hook_id = find_hook(ts->parent.t, "core", "schedchange",
604 "in", "out", "out_state", schedchange);
605 g_array_append_val(hooks, hook_id);
606
607 hook_id = find_hook(ts->parent.t, "core", "process_fork",
608 "child_pid", NULL, NULL, process_fork);
609 g_array_append_val(hooks, hook_id);
610
611 hook_id = find_hook(ts->parent.t, "core", "process_exit",
612 NULL, NULL, NULL, process_exit);
613 g_array_append_val(hooks, hook_id);
dc877563 614
615 /* Add these hooks to each before_event_by_id hooks list */
616
ba576a78 617 nb_control = ltt_trace_control_tracefile_number(ts->parent.t);
cbe7c836 618 nb_per_cpu = ltt_trace_per_cpu_tracefile_number(ts->parent.t);
dc877563 619 nb_tracefile = nb_control + nb_per_cpu;
620 for(j = 0 ; j < nb_tracefile ; j++) {
621 if(j < nb_control) {
ba576a78 622 tfs = LTTV_TRACEFILE_STATE(ts->parent.control_tracefiles[j]);
dc877563 623 }
624 else {
cbe7c836 625 tfs = LTTV_TRACEFILE_STATE(ts->parent.per_cpu_tracefiles[j-nb_control]);
dc877563 626 }
627
628 for(k = 0 ; k < hooks->len ; k++) {
629 hook_id = g_array_index(hooks, struct HookId, k);
ba576a78 630 lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.before_event_by_id,
631 hook_id.id), hook_id.h, hook_id.hook_data);
ffd54a90 632 }
dc877563 633 }
ba576a78 634 lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
635 *(val.v_pointer) = hooks;
dc877563 636 }
637}
638
639
640lttv_state_remove_event_hooks(LttvTracesetState *self)
641{
ba576a78 642 LttvTraceset *traceset = self->parent.ts;
dc877563 643
ba576a78 644 guint i, j, k, nb_trace, nb_control, nb_per_cpu, nb_tracefile;
dc877563 645
ba576a78 646 LttvTraceState *ts;
dc877563 647
ba576a78 648 LttvTracefileState *tfs;
dc877563 649
650 void *hook_data;
651
652 GArray *hooks;
653
654 struct HookId hook_id;
655
656 LttvAttributeValue val;
657
ba576a78 658 nb_trace = lttv_traceset_number(traceset);
dc877563 659 for(i = 0 ; i < nb_trace ; i++) {
ba576a78 660 ts = LTTV_TRACE_STATE(self->parent.traces[i]);
661 lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
662 hooks = *(val.v_pointer);
dc877563 663
664 /* Add these hooks to each before_event_by_id hooks list */
665
ba576a78 666 nb_control = ltt_trace_control_tracefile_number(ts->parent.t);
cbe7c836 667 nb_per_cpu = ltt_trace_per_cpu_tracefile_number(ts->parent.t);
dc877563 668 nb_tracefile = nb_control + nb_per_cpu;
669 for(j = 0 ; j < nb_tracefile ; j++) {
670 if(j < nb_control) {
ba576a78 671 tfs = LTTV_TRACEFILE_STATE(ts->parent.control_tracefiles[j]);
dc877563 672 }
673 else {
cbe7c836 674 tfs = LTTV_TRACEFILE_STATE(ts->parent.per_cpu_tracefiles[j-nb_control]);
dc877563 675 }
676
677 for(k = 0 ; k < hooks->len ; k++) {
678 hook_id = g_array_index(hooks, struct HookId, k);
ba576a78 679 lttv_hooks_remove_data(
680 lttv_hooks_by_id_find(tfs->parent.before_event_by_id,
681 hook_id.id), hook_id.h, hook_id.hook_data);
ba576a78 682 if(hook_id.free_hook_data) g_free(hook_id.hook_data);
ffd54a90 683 }
cbe7c836 684 // for(k = 0 ; k < hooks->len ; k++) {
685 // hook_id = g_array_index(hooks, struct HookId, k);
686 // if(hook_id.free_hook_data) g_free(hook_id.hook_data);
687 // }
dc877563 688 }
689 g_array_free(hooks, TRUE);
690 }
691}
692
693
ffd54a90 694void lttv_state_init(int argc, char **argv)
695{
696 LTTV_STATE_UNNAMED = g_quark_from_string("unnamed");
697 LTTV_STATE_USER_MODE = g_quark_from_string("user mode");
698 LTTV_STATE_WAIT_FORK = g_quark_from_string("wait fork");
699 LTTV_STATE_SYSCALL = g_quark_from_string("system call");
700 LTTV_STATE_TRAP = g_quark_from_string("trap");
701 LTTV_STATE_IRQ = g_quark_from_string("irq");
702 LTTV_STATE_WAIT_CPU = g_quark_from_string("wait for cpu");
703 LTTV_STATE_EXIT = g_quark_from_string("exiting");
704 LTTV_STATE_WAIT = g_quark_from_string("wait for I/O");
705 LTTV_STATE_RUN = g_quark_from_string("running");
706 LTTV_STATE_HOOKS = g_quark_from_string("saved state hooks");
707}
dc877563 708
ffd54a90 709void lttv_state_destroy()
710{
711}
dc877563 712
713
714
715
This page took 0.053708 seconds and 4 git commands to generate.