projects / lttv.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
kernel thread stack size = 1
[lttv.git] / ltt / branches / poly / lttv / lttv / state.c
... / ...
CommitLineData
1/* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Michel Dagenais
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
16 * MA 02111-1307, USA.
17 */
18
19#ifdef HAVE_CONFIG_H
20#include <config.h>
21#endif
22
23#include <lttv/lttv.h>
24#include <lttv/module.h>
25#include <lttv/state.h>
26#include <ltt/facility.h>
27#include <ltt/trace.h>
28#include <ltt/event.h>
29#include <ltt/type.h>
30#include <stdio.h>
31#include <string.h>
32
33/* Comment :
34 * Mathieu Desnoyers
35 * usertrace is there only to be able to update the current CPU of the
36 * usertraces when there is a schedchange. it is a way to link the ProcessState
37 * to the associated usertrace. Link only created upon thread creation.
38 *
39 * The cpu id is necessary : it gives us back the current ProcessState when we
40 * are considering data from the usertrace.
41 */
42
43#define PREALLOCATED_EXECUTION_STACK 10
44
45/* Facilities Quarks */
46
47GQuark
48 LTT_FACILITY_KERNEL,
49 LTT_FACILITY_KERNEL_ARCH,
50 LTT_FACILITY_PROCESS,
51 LTT_FACILITY_FS,
52 LTT_FACILITY_STATEDUMP,
53 LTT_FACILITY_USER_GENERIC;
54
55/* Events Quarks */
56
57GQuark
58 LTT_EVENT_SYSCALL_ENTRY,
59 LTT_EVENT_SYSCALL_EXIT,
60 LTT_EVENT_TRAP_ENTRY,
61 LTT_EVENT_TRAP_EXIT,
62 LTT_EVENT_IRQ_ENTRY,
63 LTT_EVENT_IRQ_EXIT,
64 LTT_EVENT_SOFT_IRQ_ENTRY,
65 LTT_EVENT_SOFT_IRQ_EXIT,
66 LTT_EVENT_SCHEDCHANGE,
67 LTT_EVENT_FORK,
68 LTT_EVENT_KERNEL_THREAD,
69 LTT_EVENT_EXIT,
70 LTT_EVENT_FREE,
71 LTT_EVENT_EXEC,
72 LTT_EVENT_ENUM_PROCESS_STATE,
73 LTT_EVENT_STATEDUMP_END,
74 LTT_EVENT_FUNCTION_ENTRY,
75 LTT_EVENT_FUNCTION_EXIT,
76 LTT_EVENT_THREAD_BRAND;
77
78/* Fields Quarks */
79
80GQuark
81 LTT_FIELD_SYSCALL_ID,
82 LTT_FIELD_TRAP_ID,
83 LTT_FIELD_IRQ_ID,
84 LTT_FIELD_SOFT_IRQ_ID,
85 LTT_FIELD_OUT,
86 LTT_FIELD_IN,
87 LTT_FIELD_OUT_STATE,
88 LTT_FIELD_PARENT_PID,
89 LTT_FIELD_CHILD_PID,
90 LTT_FIELD_PID,
91 LTT_FIELD_TGID,
92 LTT_FIELD_FILENAME,
93 LTT_FIELD_NAME,
94 LTT_FIELD_TYPE,
95 LTT_FIELD_MODE,
96 LTT_FIELD_SUBMODE,
97 LTT_FIELD_STATUS,
98 LTT_FIELD_THIS_FN,
99 LTT_FIELD_CALL_SITE;
100
101LttvExecutionMode
102 LTTV_STATE_MODE_UNKNOWN,
103 LTTV_STATE_USER_MODE,
104 LTTV_STATE_SYSCALL,
105 LTTV_STATE_TRAP,
106 LTTV_STATE_IRQ,
107 LTTV_STATE_SOFT_IRQ;
108
109LttvExecutionSubmode
110 LTTV_STATE_SUBMODE_UNKNOWN,
111 LTTV_STATE_SUBMODE_NONE;
112
113LttvProcessStatus
114 LTTV_STATE_UNNAMED,
115 LTTV_STATE_WAIT_FORK,
116 LTTV_STATE_WAIT_CPU,
117 LTTV_STATE_EXIT,
118 LTTV_STATE_ZOMBIE,
119 LTTV_STATE_WAIT,
120 LTTV_STATE_RUN,
121 LTTV_STATE_DEAD;
122
123GQuark
124 LTTV_STATE_UNBRANDED;
125
126LttvProcessType
127 LTTV_STATE_USER_THREAD,
128 LTTV_STATE_KERNEL_THREAD;
129
130static GQuark
131 LTTV_STATE_TRACEFILES,
132 LTTV_STATE_PROCESSES,
133 LTTV_STATE_PROCESS,
134 LTTV_STATE_RUNNING_PROCESS,
135 LTTV_STATE_EVENT,
136 LTTV_STATE_SAVED_STATES,
137 LTTV_STATE_SAVED_STATES_TIME,
138 LTTV_STATE_TIME,
139 LTTV_STATE_HOOKS,
140 LTTV_STATE_NAME_TABLES,
141 LTTV_STATE_TRACE_STATE_USE_COUNT;
142
143static void create_max_time(LttvTraceState *tcs);
144
145static void get_max_time(LttvTraceState *tcs);
146
147static void free_max_time(LttvTraceState *tcs);
148
149static void create_name_tables(LttvTraceState *tcs);
150
151static void get_name_tables(LttvTraceState *tcs);
152
153static void free_name_tables(LttvTraceState *tcs);
154
155static void free_saved_state(LttvTraceState *tcs);
156
157static void lttv_state_free_process_table(GHashTable *processes);
158
159static void lttv_trace_states_read_raw(LttvTraceState *tcs, FILE *fp,
160 GPtrArray *quarktable);
161
162void lttv_state_save(LttvTraceState *self, LttvAttribute *container)
163{
164 LTTV_TRACE_STATE_GET_CLASS(self)->state_save(self, container);
165}
166
167
168void lttv_state_restore(LttvTraceState *self, LttvAttribute *container)
169{
170 LTTV_TRACE_STATE_GET_CLASS(self)->state_restore(self, container);
171}
172
173
174void lttv_state_state_saved_free(LttvTraceState *self,
175 LttvAttribute *container)
176{
177 LTTV_TRACE_STATE_GET_CLASS(self)->state_saved_free(self, container);
178}
179
180
181guint process_hash(gconstpointer key)
182{
183 guint pid = ((const LttvProcessState *)key)->pid;
184 return (pid>>8 ^ pid>>4 ^ pid>>2 ^ pid) ;
185}
186
187
188/* If the hash table hash function is well distributed,
189 * the process_equal should compare different pid */
190gboolean process_equal(gconstpointer a, gconstpointer b)
191{
192 const LttvProcessState *process_a, *process_b;
193 gboolean ret = TRUE;
194
195 process_a = (const LttvProcessState *)a;
196 process_b = (const LttvProcessState *)b;
197
198 if(likely(process_a->pid != process_b->pid)) ret = FALSE;
199 else if(likely(process_a->pid == 0 &&
200 process_a->cpu != process_b->cpu)) ret = FALSE;
201
202 return ret;
203}
204
205static void delete_usertrace(gpointer key, gpointer value, gpointer user_data)
206{
207 g_tree_destroy((GTree*)value);
208}
209
210static void lttv_state_free_usertraces(GHashTable *usertraces)
211{
212 g_hash_table_foreach(usertraces, delete_usertrace, NULL);
213 g_hash_table_destroy(usertraces);
214}
215
216
217
218static void
219restore_init_state(LttvTraceState *self)
220{
221 guint i, nb_cpus;
222
223 LttvTracefileState *tfcs;
224
225 LttTime start_time, end_time;
226
227 /* Free the process tables */
228 if(self->processes != NULL) lttv_state_free_process_table(self->processes);
229 if(self->usertraces != NULL) lttv_state_free_usertraces(self->usertraces);
230 self->processes = g_hash_table_new(process_hash, process_equal);
231 self->usertraces = g_hash_table_new(g_direct_hash, g_direct_equal);
232 self->nb_event = 0;
233
234 /* Seek time to beginning */
235 // Mathieu : fix : don't seek traceset here : causes inconsistency in seek
236 // closest. It's the tracecontext job to seek the trace to the beginning
237 // anyway : the init state might be used at the middle of the trace as well...
238 //g_tree_destroy(self->parent.ts_context->pqueue);
239 //self->parent.ts_context->pqueue = g_tree_new(compare_tracefile);
240
241 ltt_trace_time_span_get(self->parent.t, &start_time, &end_time);
242
243 //lttv_process_trace_seek_time(&self->parent, ltt_time_zero);
244
245 nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
246
247 /* Put the per cpu running_process to beginning state : process 0. */
248 for(i=0; i< nb_cpus; i++) {
249 LttvExecutionState *es;
250 self->running_process[i] = lttv_state_create_process(self, NULL, i, 0, 0,
251 LTTV_STATE_UNNAMED, &start_time);
252 /* We are not sure is it's a kernel thread or normal thread, put the
253 * bottom stack state to unknown */
254 self->running_process[i]->execution_stack =
255 g_array_set_size(self->running_process[i]->execution_stack, 1);
256 es = self->running_process[i]->state =
257 &g_array_index(self->running_process[i]->execution_stack,
258 LttvExecutionState, 0);
259 es->t = LTTV_STATE_MODE_UNKNOWN;
260 es->s = LTTV_STATE_UNNAMED;
261
262 //self->running_process[i]->state->s = LTTV_STATE_RUN;
263 self->running_process[i]->cpu = i;
264 }
265
266#if 0
267 nb_tracefile = self->parent.tracefiles->len;
268
269 for(i = 0 ; i < nb_tracefile ; i++) {
270 tfcs =
271 LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
272 LttvTracefileContext*, i));
273 ltt_trace_time_span_get(self->parent.t, &tfcs->parent.timestamp, NULL);
274// tfcs->saved_position = 0;
275 tfcs->process = lttv_state_create_process(tfcs, NULL,0);
276 tfcs->process->state->s = LTTV_STATE_RUN;
277 tfcs->process->last_cpu = tfcs->cpu_name;
278 tfcs->process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfcs)->tf);
279 }
280#endif //0
281}
282
283//static LttTime time_zero = {0,0};
284
285static gint compare_usertraces(gconstpointer a, gconstpointer b,
286 gpointer user_data)
287{
288 const LttTime *t1 = (const LttTime *)a;
289 const LttTime *t2 = (const LttTime *)b;
290
291 return ltt_time_compare(*t1, *t2);
292}
293
294static void free_usertrace_key(gpointer data)
295{
296 g_free(data);
297}
298
299#define MAX_STRING_LEN 4096
300
301static void
302state_load_saved_states(LttvTraceState *tcs)
303{
304 FILE *fp;
305 GPtrArray *quarktable;
306 char *trace_path;
307 char path[PATH_MAX];
308 guint count;
309 guint i;
310 tcs->has_precomputed_states = FALSE;
311 GQuark q;
312 gchar *string;
313 gint hdr;
314 gchar buf[MAX_STRING_LEN];
315 guint len;
316
317 trace_path = g_quark_to_string(ltt_trace_name(tcs->parent.t));
318 strncpy(path, trace_path, PATH_MAX-1);
319 count = strnlen(trace_path, PATH_MAX-1);
320 // quarktable : open, test
321 strncat(path, "/precomputed/quarktable", PATH_MAX-count-1);
322 fp = fopen(path, "r");
323 if(!fp) return;
324 quarktable = g_ptr_array_sized_new(4096);
325
326 /* Index 0 is null */
327 hdr = fgetc(fp);
328 if(hdr == EOF) return;
329 g_assert(hdr == HDR_QUARKS);
330 q = 1;
331 do {
332 hdr = fgetc(fp);
333 if(hdr == EOF) break;
334 g_assert(hdr == HDR_QUARK);
335 g_ptr_array_set_size(quarktable, q+1);
336 i=0;
337 while(1) {
338 fread(&buf[i], sizeof(gchar), 1, fp);
339 if(buf[i] == '\0' || feof(fp)) break;
340 i++;
341 }
342 len = strnlen(buf, MAX_STRING_LEN-1);
343 g_ptr_array_index (quarktable, q) = g_new(gchar, len+1);
344 strncpy(g_ptr_array_index (quarktable, q), buf, len+1);
345 q++;
346 } while(1);
347
348 fclose(fp);
349
350 // saved_states : open, test
351 strncpy(path, trace_path, PATH_MAX-1);
352 count = strnlen(trace_path, PATH_MAX-1);
353 strncat(path, "/precomputed/states", PATH_MAX-count-1);
354 fp = fopen(path, "r");
355 if(!fp) return;
356
357 hdr = fgetc(fp);
358 if(hdr != HDR_TRACE) goto end;
359
360 lttv_trace_states_read_raw(tcs, fp, quarktable);
361
362 tcs->has_precomputed_states = TRUE;
363
364end:
365 fclose(fp);
366
367 /* Free the quarktable */
368 for(i=0; i<quarktable->len; i++) {
369 string = g_ptr_array_index (quarktable, i);
370 g_free(string);
371 }
372 g_ptr_array_free(quarktable, TRUE);
373 return;
374}
375
376static void
377init(LttvTracesetState *self, LttvTraceset *ts)
378{
379 guint i, j, nb_trace, nb_tracefile;
380
381 LttvTraceContext *tc;
382
383 LttvTraceState *tcs;
384
385 LttvTracefileState *tfcs;
386
387 LttvAttributeValue v;
388
389 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
390 init((LttvTracesetContext *)self, ts);
391
392 nb_trace = lttv_traceset_number(ts);
393 for(i = 0 ; i < nb_trace ; i++) {
394 tc = self->parent.traces[i];
395 tcs = LTTV_TRACE_STATE(tc);
396 tcs->save_interval = LTTV_STATE_SAVE_INTERVAL;
397 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_TRACE_STATE_USE_COUNT,
398 LTTV_UINT, &v);
399 (*v.v_uint)++;
400
401 if(*(v.v_uint) == 1) {
402 create_name_tables(tcs);
403 create_max_time(tcs);
404 }
405 get_name_tables(tcs);
406 get_max_time(tcs);
407
408 nb_tracefile = tc->tracefiles->len;
409 tcs->processes = NULL;
410 tcs->usertraces = NULL;
411 tcs->running_process = g_new(LttvProcessState*,
412 ltt_trace_get_num_cpu(tc->t));
413 restore_init_state(tcs);
414 for(j = 0 ; j < nb_tracefile ; j++) {
415 tfcs =
416 LTTV_TRACEFILE_STATE(g_array_index(tc->tracefiles,
417 LttvTracefileContext*, j));
418 tfcs->tracefile_name = ltt_tracefile_name(tfcs->parent.tf);
419 tfcs->cpu = ltt_tracefile_cpu(tfcs->parent.tf);
420 if(ltt_tracefile_tid(tfcs->parent.tf) != 0) {
421 /* It's a Usertrace */
422 guint tid = ltt_tracefile_tid(tfcs->parent.tf);
423 GTree *usertrace_tree = (GTree*)g_hash_table_lookup(tcs->usertraces,
424 (gconstpointer)tid);
425 if(!usertrace_tree) {
426 usertrace_tree = g_tree_new_full(compare_usertraces,
427 NULL, free_usertrace_key, NULL);
428 g_hash_table_insert(tcs->usertraces,
429 (gpointer)tid, usertrace_tree);
430 }
431 LttTime *timestamp = g_new(LttTime, 1);
432 *timestamp = ltt_interpolate_time_from_tsc(tfcs->parent.tf,
433 ltt_tracefile_creation(tfcs->parent.tf));
434 g_tree_insert(usertrace_tree, timestamp, tfcs);
435 }
436 }
437
438 /* See if the trace has saved states */
439 state_load_saved_states(tcs);
440 }
441}
442
443static void
444fini(LttvTracesetState *self)
445{
446 guint i, nb_trace;
447
448 LttvTraceState *tcs;
449
450 LttvTracefileState *tfcs;
451
452 LttvAttributeValue v;
453
454 nb_trace = lttv_traceset_number(LTTV_TRACESET_CONTEXT(self)->ts);
455 for(i = 0 ; i < nb_trace ; i++) {
456 tcs = (LttvTraceState *)(LTTV_TRACESET_CONTEXT(self)->traces[i]);
457 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_TRACE_STATE_USE_COUNT,
458 LTTV_UINT, &v);
459
460 g_assert(*(v.v_uint) != 0);
461 (*v.v_uint)--;
462
463 if(*(v.v_uint) == 0) {
464 free_name_tables(tcs);
465 free_max_time(tcs);
466 free_saved_state(tcs);
467 }
468 g_free(tcs->running_process);
469 tcs->running_process = NULL;
470 lttv_state_free_process_table(tcs->processes);
471 lttv_state_free_usertraces(tcs->usertraces);
472 tcs->processes = NULL;
473 tcs->usertraces = NULL;
474 }
475 LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
476 fini((LttvTracesetContext *)self);
477}
478
479
480static LttvTracesetContext *
481new_traceset_context(LttvTracesetContext *self)
482{
483 return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE, NULL));
484}
485
486
487static LttvTraceContext *
488new_trace_context(LttvTracesetContext *self)
489{
490 return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE, NULL));
491}
492
493
494static LttvTracefileContext *
495new_tracefile_context(LttvTracesetContext *self)
496{
497 return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE, NULL));
498}
499
500
501/* Write the process state of the trace */
502
503static void write_process_state(gpointer key, gpointer value,
504 gpointer user_data)
505{
506 LttvProcessState *process;
507
508 LttvExecutionState *es;
509
510 FILE *fp = (FILE *)user_data;
511
512 guint i;
513 guint64 address;
514
515 process = (LttvProcessState *)value;
516 fprintf(fp,
517" <PROCESS CORE=%p PID=%u TGID=%u PPID=%u TYPE=\"%s\" CTIME_S=%lu CTIME_NS=%lu ITIME_S=%lu ITIME_NS=%lu NAME=\"%s\" BRAND=\"%s\" CPU=\"%u\">\n",
518 process, process->pid, process->tgid, process->ppid,
519 g_quark_to_string(process->type),
520 process->creation_time.tv_sec,
521 process->creation_time.tv_nsec,
522 process->insertion_time.tv_sec,
523 process->insertion_time.tv_nsec,
524 g_quark_to_string(process->name),
525 g_quark_to_string(process->brand),
526 process->cpu);
527
528 for(i = 0 ; i < process->execution_stack->len; i++) {
529 es = &g_array_index(process->execution_stack, LttvExecutionState, i);
530 fprintf(fp, " <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
531 g_quark_to_string(es->t), g_quark_to_string(es->n),
532 es->entry.tv_sec, es->entry.tv_nsec);
533 fprintf(fp, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
534 es->change.tv_sec, es->change.tv_nsec, g_quark_to_string(es->s));
535 }
536
537 for(i = 0 ; i < process->user_stack->len; i++) {
538 address = &g_array_index(process->user_stack, guint64, i);
539 fprintf(fp, " <USER_STACK ADDRESS=\"%llu\"/>\n",
540 address);
541 }
542
543 if(process->usertrace) {
544 fprintf(fp, " <USERTRACE NAME=\"%s\" CPU=%u\n/>",
545 g_quark_to_string(process->usertrace->tracefile_name),
546 process->usertrace->cpu);
547 }
548
549
550 fprintf(fp, " </PROCESS>\n");
551}
552
553
554void lttv_state_write(LttvTraceState *self, LttTime t, FILE *fp)
555{
556 guint i, nb_tracefile, nb_block, offset;
557 guint64 tsc;
558
559 LttvTracefileState *tfcs;
560
561 LttTracefile *tf;
562
563 LttEventPosition *ep;
564
565 guint nb_cpus;
566
567 ep = ltt_event_position_new();
568
569 fprintf(fp,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t.tv_sec, t.tv_nsec);
570
571 g_hash_table_foreach(self->processes, write_process_state, fp);
572
573 nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
574 for(i=0;i<nb_cpus;i++) {
575 fprintf(fp," <CPU NUM=%u RUNNING_PROCESS=%u>\n",
576 i, self->running_process[i]->pid);
577 }
578
579 nb_tracefile = self->parent.tracefiles->len;
580
581 for(i = 0 ; i < nb_tracefile ; i++) {
582 tfcs =
583 LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
584 LttvTracefileContext*, i));
585 fprintf(fp, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
586 tfcs->parent.timestamp.tv_sec,
587 tfcs->parent.timestamp.tv_nsec);
588 LttEvent *e = ltt_tracefile_get_event(tfcs->parent.tf);
589 if(e == NULL) fprintf(fp,"/>\n");
590 else {
591 ltt_event_position(e, ep);
592 ltt_event_position_get(ep, &tf, &nb_block, &offset, &tsc);
593 fprintf(fp, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block, offset,
594 tsc);
595 }
596 }
597 g_free(ep);
598 fprintf(fp,"</PROCESS_STATE>\n");
599}
600
601
602static void write_process_state_raw(gpointer key, gpointer value,
603 gpointer user_data)
604{
605 LttvProcessState *process;
606
607 LttvExecutionState *es;
608
609 FILE *fp = (FILE *)user_data;
610
611 guint i;
612 guint64 address;
613
614 process = (LttvProcessState *)value;
615 fputc(HDR_PROCESS, fp);
616 //fwrite(&header, sizeof(header), 1, fp);
617 //fprintf(fp, "%s", g_quark_to_string(process->type));
618 //fputc('\0', fp);
619 fwrite(&process->type, sizeof(process->type), 1, fp);
620 //fprintf(fp, "%s", g_quark_to_string(process->name));
621 //fputc('\0', fp);
622 fwrite(&process->name, sizeof(process->name), 1, fp);
623 //fprintf(fp, "%s", g_quark_to_string(process->brand));
624 //fputc('\0', fp);
625 fwrite(&process->brand, sizeof(process->brand), 1, fp);
626 fwrite(&process->pid, sizeof(process->pid), 1, fp);
627 fwrite(&process->tgid, sizeof(process->tgid), 1, fp);
628 fwrite(&process->ppid, sizeof(process->ppid), 1, fp);
629 fwrite(&process->cpu, sizeof(process->cpu), 1, fp);
630 fwrite(&process->creation_time, sizeof(process->creation_time), 1, fp);
631 fwrite(&process->insertion_time, sizeof(process->insertion_time), 1, fp);
632
633#if 0
634 fprintf(fp,
635" <PROCESS CORE=%p PID=%u TGID=%u PPID=%u TYPE=\"%s\" CTIME_S=%lu CTIME_NS=%lu ITIME_S=%lu ITIME_NS=%lu NAME=\"%s\" BRAND=\"%s\" CPU=\"%u\" PROCESS_TYPE=%u>\n",
636 process, process->pid, process->tgid, process->ppid,
637 g_quark_to_string(process->type),
638 process->creation_time.tv_sec,
639 process->creation_time.tv_nsec,
640 process->insertion_time.tv_sec,
641 process->insertion_time.tv_nsec,
642 g_quark_to_string(process->name),
643 g_quark_to_string(process->brand),
644 process->cpu);
645#endif //0
646
647 for(i = 0 ; i < process->execution_stack->len; i++) {
648 es = &g_array_index(process->execution_stack, LttvExecutionState, i);
649
650 fputc(HDR_ES, fp);
651 //fprintf(fp, "%s", g_quark_to_string(es->t));
652 //fputc('\0', fp);
653 fwrite(&es->t, sizeof(es->t), 1, fp);
654 //fprintf(fp, "%s", g_quark_to_string(es->n));
655 //fputc('\0', fp);
656 fwrite(&es->n, sizeof(es->n), 1, fp);
657 //fprintf(fp, "%s", g_quark_to_string(es->s));
658 //fputc('\0', fp);
659 fwrite(&es->s, sizeof(es->s), 1, fp);
660 fwrite(&es->entry, sizeof(es->entry), 1, fp);
661 fwrite(&es->change, sizeof(es->change), 1, fp);
662 fwrite(&es->cum_cpu_time, sizeof(es->cum_cpu_time), 1, fp);
663#if 0
664 fprintf(fp, " <ES MODE=\"%s\" SUBMODE=\"%s\" ENTRY_S=%lu ENTRY_NS=%lu",
665 g_quark_to_string(es->t), g_quark_to_string(es->n),
666 es->entry.tv_sec, es->entry.tv_nsec);
667 fprintf(fp, " CHANGE_S=%lu CHANGE_NS=%lu STATUS=\"%s\"/>\n",
668 es->change.tv_sec, es->change.tv_nsec, g_quark_to_string(es->s));
669#endif //0
670 }
671
672 for(i = 0 ; i < process->user_stack->len; i++) {
673 address = &g_array_index(process->user_stack, guint64, i);
674 fputc(HDR_USER_STACK, fp);
675 fwrite(&address, sizeof(address), 1, fp);
676#if 0
677 fprintf(fp, " <USER_STACK ADDRESS=\"%llu\"/>\n",
678 address);
679#endif //0
680 }
681
682 if(process->usertrace) {
683 fputc(HDR_USERTRACE, fp);
684 //fprintf(fp, "%s", g_quark_to_string(process->usertrace->tracefile_name));
685 //fputc('\0', fp);
686 fwrite(&process->usertrace->tracefile_name,
687 sizeof(process->usertrace->tracefile_name), 1, fp);
688 fwrite(&process->usertrace->cpu, sizeof(process->usertrace->cpu), 1, fp);
689#if 0
690 fprintf(fp, " <USERTRACE NAME=\"%s\" CPU=%u\n/>",
691 g_quark_to_string(process->usertrace->tracefile_name),
692 process->usertrace->cpu);
693#endif //0
694 }
695
696}
697
698
699void lttv_state_write_raw(LttvTraceState *self, LttTime t, FILE *fp)
700{
701 guint i, nb_tracefile, nb_block, offset;
702 guint64 tsc;
703
704 LttvTracefileState *tfcs;
705
706 LttTracefile *tf;
707
708 LttEventPosition *ep;
709
710 guint nb_cpus;
711
712 ep = ltt_event_position_new();
713
714 //fprintf(fp,"<PROCESS_STATE TIME_S=%lu TIME_NS=%lu>\n", t.tv_sec, t.tv_nsec);
715 fputc(HDR_PROCESS_STATE, fp);
716 fwrite(&t, sizeof(t), 1, fp);
717
718 g_hash_table_foreach(self->processes, write_process_state_raw, fp);
719
720 nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
721 for(i=0;i<nb_cpus;i++) {
722 fputc(HDR_CPU, fp);
723 fwrite(&i, sizeof(i), 1, fp); /* cpu number */
724 fwrite(&self->running_process[i]->pid,
725 sizeof(self->running_process[i]->pid), 1, fp);
726 //fprintf(fp," <CPU NUM=%u RUNNING_PROCESS=%u>\n",
727 // i, self->running_process[i]->pid);
728 }
729
730 nb_tracefile = self->parent.tracefiles->len;
731
732 for(i = 0 ; i < nb_tracefile ; i++) {
733 tfcs =
734 LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
735 LttvTracefileContext*, i));
736 // fprintf(fp, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
737 // tfcs->parent.timestamp.tv_sec,
738 // tfcs->parent.timestamp.tv_nsec);
739 fputc(HDR_TRACEFILE, fp);
740 fwrite(&tfcs->parent.timestamp, sizeof(tfcs->parent.timestamp), 1, fp);
741 /* Note : if timestamp if LTT_TIME_INFINITE, there will be no
742 * position following : end of trace */
743 LttEvent *e = ltt_tracefile_get_event(tfcs->parent.tf);
744 if(e != NULL) {
745 ltt_event_position(e, ep);
746 ltt_event_position_get(ep, &tf, &nb_block, &offset, &tsc);
747 //fprintf(fp, " BLOCK=%u OFFSET=%u TSC=%llu/>\n", nb_block, offset,
748 // tsc);
749 fwrite(&nb_block, sizeof(nb_block), 1, fp);
750 fwrite(&offset, sizeof(offset), 1, fp);
751 fwrite(&tsc, sizeof(tsc), 1, fp);
752 }
753 }
754 g_free(ep);
755}
756
757
758/* Read process state from a file */
759
760/* Called because a HDR_PROCESS was found */
761static void read_process_state_raw(LttvTraceState *self, FILE *fp,
762 GPtrArray *quarktable)
763{
764 LttvExecutionState *es;
765 LttvProcessState *process, *parent_process;
766 LttvProcessState tmp;
767 GQuark tmpq;
768
769 guint i;
770 guint64 *address;
771 guint cpu;
772
773 /* TODO : check return value */
774 fread(&tmp.type, sizeof(tmp.type), 1, fp);
775 fread(&tmp.name, sizeof(tmp.name), 1, fp);
776 fread(&tmp.brand, sizeof(tmp.brand), 1, fp);
777 fread(&tmp.pid, sizeof(tmp.pid), 1, fp);
778 fread(&tmp.tgid, sizeof(tmp.tgid), 1, fp);
779 fread(&tmp.ppid, sizeof(tmp.ppid), 1, fp);
780 fread(&tmp.cpu, sizeof(tmp.cpu), 1, fp);
781 fread(&tmp.creation_time, sizeof(tmp.creation_time), 1, fp);
782 fread(&tmp.insertion_time, sizeof(tmp.insertion_time), 1, fp);
783
784 if(tmp.pid == 0) {
785 process = lttv_state_find_process(self, tmp.cpu, tmp.pid);
786 } else {
787 /* We must link to the parent */
788 parent_process = lttv_state_find_process_or_create(self, ANY_CPU, tmp.ppid,
789 &ltt_time_zero);
790 process = lttv_state_find_process(self, ANY_CPU, tmp.pid);
791 if(process == NULL) {
792 process = lttv_state_create_process(self, parent_process, tmp.cpu,
793 tmp.pid, tmp.tgid,
794 g_quark_from_string((gchar*)g_ptr_array_index(quarktable, tmp.name)),
795 &tmp.creation_time);
796 }
797 }
798 process->insertion_time = tmp.insertion_time;
799 process->creation_time = tmp.creation_time;
800 process->type = g_quark_from_string(
801 (gchar*)g_ptr_array_index(quarktable, tmp.type));
802 process->tgid = tmp.tgid;
803 process->ppid = tmp.ppid;
804 process->brand = g_quark_from_string(
805 (gchar*)g_ptr_array_index(quarktable, tmp.brand));
806 process->name =
807 g_quark_from_string((gchar*)g_ptr_array_index(quarktable, tmp.name));
808
809
810 do {
811 if(feof(fp) || ferror(fp)) goto end_loop;
812
813 gint hdr = fgetc(fp);
814 if(hdr == EOF) goto end_loop;
815
816 switch(hdr) {
817 case HDR_ES:
818 process->execution_stack =
819 g_array_set_size(process->execution_stack,
820 process->execution_stack->len + 1);
821 es = &g_array_index(process->execution_stack, LttvExecutionState,
822 process->execution_stack->len-1);
823 process->state = es;
824
825 fread(&es->t, sizeof(es->t), 1, fp);
826 es->t = g_quark_from_string(
827 (gchar*)g_ptr_array_index(quarktable, es->t));
828 fread(&es->n, sizeof(es->n), 1, fp);
829 es->n = g_quark_from_string(
830 (gchar*)g_ptr_array_index(quarktable, es->n));
831 fread(&es->s, sizeof(es->s), 1, fp);
832 es->s = g_quark_from_string(
833 (gchar*)g_ptr_array_index(quarktable, es->s));
834 fread(&es->entry, sizeof(es->entry), 1, fp);
835 fread(&es->change, sizeof(es->change), 1, fp);
836 fread(&es->cum_cpu_time, sizeof(es->cum_cpu_time), 1, fp);
837 break;
838 case HDR_USER_STACK:
839 process->user_stack = g_array_set_size(process->user_stack,
840 process->user_stack->len + 1);
841 address = &g_array_index(process->user_stack, guint64,
842 process->user_stack->len-1);
843 fread(address, sizeof(address), 1, fp);
844 process->current_function = *address;
845 break;
846 case HDR_USERTRACE:
847 fread(&tmpq, sizeof(tmpq), 1, fp);
848 fread(&process->usertrace->cpu, sizeof(process->usertrace->cpu), 1, fp);
849 break;
850 default:
851 ungetc(hdr, fp);
852 goto end_loop;
853 };
854 } while(1);
855end_loop:
856 return;
857}
858
859
860/* Called because a HDR_PROCESS_STATE was found */
861/* Append a saved state to the trace states */
862void lttv_state_read_raw(LttvTraceState *self, FILE *fp, GPtrArray *quarktable)
863{
864 guint i, nb_tracefile, nb_block, offset;
865 guint64 tsc;
866 LttvTracefileState *tfcs;
867
868 LttEventPosition *ep;
869
870 guint nb_cpus;
871
872 int hdr;
873
874 LttTime t;
875
876 LttvAttribute *saved_states_tree, *saved_state_tree;
877
878 LttvAttributeValue value;
879 GTree *pqueue = self->parent.ts_context->pqueue;
880 ep = ltt_event_position_new();
881
882 restore_init_state(self);
883
884 fread(&t, sizeof(t), 1, fp);
885
886 do {
887 if(feof(fp) || ferror(fp)) goto end_loop;
888 hdr = fgetc(fp);
889 if(hdr == EOF) goto end_loop;
890
891 switch(hdr) {
892 case HDR_PROCESS:
893 /* Call read_process_state_raw */
894 read_process_state_raw(self, fp, quarktable);
895 break;
896 case HDR_TRACEFILE:
897 case HDR_TRACESET:
898 case HDR_TRACE:
899 case HDR_QUARKS:
900 case HDR_QUARK:
901 case HDR_ES:
902 case HDR_USER_STACK:
903 case HDR_USERTRACE:
904 case HDR_PROCESS_STATE:
905 case HDR_CPU:
906 ungetc(hdr, fp);
907 goto end_loop;
908 break;
909 default:
910 g_error("Error while parsing saved state file : unknown data header %d",
911 hdr);
912 };
913 } while(1);
914end_loop:
915
916 nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
917 for(i=0;i<nb_cpus;i++) {
918 int cpu_num;
919 hdr = fgetc(fp);
920 g_assert(hdr == HDR_CPU);
921 fread(&cpu_num, sizeof(cpu_num), 1, fp); /* cpu number */
922 g_assert(i == cpu_num);
923 fread(&self->running_process[i]->pid,
924 sizeof(self->running_process[i]->pid), 1, fp);
925 }
926
927 nb_tracefile = self->parent.tracefiles->len;
928
929 for(i = 0 ; i < nb_tracefile ; i++) {
930 tfcs =
931 LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
932 LttvTracefileContext*, i));
933 // fprintf(fp, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
934 // tfcs->parent.timestamp.tv_sec,
935 // tfcs->parent.timestamp.tv_nsec);
936 g_tree_remove(pqueue, &tfcs->parent);
937 hdr = fgetc(fp);
938 g_assert(hdr == HDR_TRACEFILE);
939 fread(&tfcs->parent.timestamp, sizeof(tfcs->parent.timestamp), 1, fp);
940 /* Note : if timestamp if LTT_TIME_INFINITE, there will be no
941 * position following : end of trace */
942 if(ltt_time_compare(tfcs->parent.timestamp, ltt_time_infinite) != 0) {
943 fread(&nb_block, sizeof(nb_block), 1, fp);
944 fread(&offset, sizeof(offset), 1, fp);
945 fread(&tsc, sizeof(tsc), 1, fp);
946 ltt_event_position_set(ep, tfcs->parent.tf, nb_block, offset, tsc);
947 gint ret = ltt_tracefile_seek_position(tfcs->parent.tf, ep);
948 g_assert(ret == 0);
949 g_tree_insert(pqueue, &tfcs->parent, &tfcs->parent);
950 }
951 }
952 g_free(ep);
953
954 saved_states_tree = lttv_attribute_find_subdir(self->parent.t_a,
955 LTTV_STATE_SAVED_STATES);
956 saved_state_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
957 value = lttv_attribute_add(saved_states_tree,
958 lttv_attribute_get_number(saved_states_tree), LTTV_GOBJECT);
959 *(value.v_gobject) = (GObject *)saved_state_tree;
960 value = lttv_attribute_add(saved_state_tree, LTTV_STATE_TIME, LTTV_TIME);
961 *(value.v_time) = t;
962 lttv_state_save(self, saved_state_tree);
963 g_debug("Saving state at time %lu.%lu", t.tv_sec,
964 t.tv_nsec);
965
966 *(self->max_time_state_recomputed_in_seek) = t;
967
968}
969
970/* Called when a HDR_TRACE is found */
971void lttv_trace_states_read_raw(LttvTraceState *tcs, FILE *fp,
972 GPtrArray *quarktable)
973{
974 int hdr;
975
976 do {
977 if(feof(fp) || ferror(fp)) goto end_loop;
978 hdr = fgetc(fp);
979 if(hdr == EOF) goto end_loop;
980
981 switch(hdr) {
982 case HDR_PROCESS_STATE:
983 /* Call read_process_state_raw */
984 lttv_state_read_raw(tcs, fp, quarktable);
985 break;
986 case HDR_TRACEFILE:
987 case HDR_TRACESET:
988 case HDR_TRACE:
989 case HDR_QUARKS:
990 case HDR_QUARK:
991 case HDR_ES:
992 case HDR_USER_STACK:
993 case HDR_USERTRACE:
994 case HDR_PROCESS:
995 case HDR_CPU:
996 g_error("Error while parsing saved state file :"
997 " unexpected data header %d",
998 hdr);
999 break;
1000 default:
1001 g_error("Error while parsing saved state file : unknown data header %d",
1002 hdr);
1003 };
1004 } while(1);
1005end_loop:
1006 *(tcs->max_time_state_recomputed_in_seek) = tcs->parent.time_span.end_time;
1007 restore_init_state(tcs);
1008 lttv_process_trace_seek_time(tcs, ltt_time_zero);
1009 return;
1010}
1011
1012
1013
1014/* Copy each process from an existing hash table to a new one */
1015
1016static void copy_process_state(gpointer key, gpointer value,gpointer user_data)
1017{
1018 LttvProcessState *process, *new_process;
1019
1020 GHashTable *new_processes = (GHashTable *)user_data;
1021
1022 guint i;
1023
1024 process = (LttvProcessState *)value;
1025 new_process = g_new(LttvProcessState, 1);
1026 *new_process = *process;
1027 new_process->execution_stack = g_array_sized_new(FALSE, FALSE,
1028 sizeof(LttvExecutionState), PREALLOCATED_EXECUTION_STACK);
1029 new_process->execution_stack =
1030 g_array_set_size(new_process->execution_stack,
1031 process->execution_stack->len);
1032 for(i = 0 ; i < process->execution_stack->len; i++) {
1033 g_array_index(new_process->execution_stack, LttvExecutionState, i) =
1034 g_array_index(process->execution_stack, LttvExecutionState, i);
1035 }
1036 new_process->state = &g_array_index(new_process->execution_stack,
1037 LttvExecutionState, new_process->execution_stack->len - 1);
1038 new_process->user_stack = g_array_sized_new(FALSE, FALSE,
1039 sizeof(guint64), 0);
1040 new_process->user_stack =
1041 g_array_set_size(new_process->user_stack,
1042 process->user_stack->len);
1043 for(i = 0 ; i < process->user_stack->len; i++) {
1044 g_array_index(new_process->user_stack, guint64, i) =
1045 g_array_index(process->user_stack, guint64, i);
1046 }
1047 new_process->current_function = process->current_function;
1048 g_hash_table_insert(new_processes, new_process, new_process);
1049}
1050
1051
1052static GHashTable *lttv_state_copy_process_table(GHashTable *processes)
1053{
1054 GHashTable *new_processes = g_hash_table_new(process_hash, process_equal);
1055
1056 g_hash_table_foreach(processes, copy_process_state, new_processes);
1057 return new_processes;
1058}
1059
1060
1061/* The saved state for each trace contains a member "processes", which
1062 stores a copy of the process table, and a member "tracefiles" with
1063 one entry per tracefile. Each tracefile has a "process" member pointing
1064 to the current process and a "position" member storing the tracefile
1065 position (needed to seek to the current "next" event. */
1066
1067static void state_save(LttvTraceState *self, LttvAttribute *container)
1068{
1069 guint i, nb_tracefile, nb_cpus;
1070
1071 LttvTracefileState *tfcs;
1072
1073 LttvAttribute *tracefiles_tree, *tracefile_tree;
1074
1075 guint *running_process;
1076
1077 LttvAttributeType type;
1078
1079 LttvAttributeValue value;
1080
1081 LttvAttributeName name;
1082
1083 LttEventPosition *ep;
1084
1085 tracefiles_tree = lttv_attribute_find_subdir(container,
1086 LTTV_STATE_TRACEFILES);
1087
1088 value = lttv_attribute_add(container, LTTV_STATE_PROCESSES,
1089 LTTV_POINTER);
1090 *(value.v_pointer) = lttv_state_copy_process_table(self->processes);
1091
1092 /* Add the currently running processes array */
1093 nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
1094 running_process = g_new(guint, nb_cpus);
1095 for(i=0;i<nb_cpus;i++) {
1096 running_process[i] = self->running_process[i]->pid;
1097 }
1098 value = lttv_attribute_add(container, LTTV_STATE_RUNNING_PROCESS,
1099 LTTV_POINTER);
1100 *(value.v_pointer) = running_process;
1101
1102 g_info("State save");
1103
1104 nb_tracefile = self->parent.tracefiles->len;
1105
1106 for(i = 0 ; i < nb_tracefile ; i++) {
1107 tfcs =
1108 LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
1109 LttvTracefileContext*, i));
1110 tracefile_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
1111 value = lttv_attribute_add(tracefiles_tree, i,
1112 LTTV_GOBJECT);
1113 *(value.v_gobject) = (GObject *)tracefile_tree;
1114#if 0
1115 value = lttv_attribute_add(tracefile_tree, LTTV_STATE_PROCESS,
1116 LTTV_UINT);
1117 *(value.v_uint) = tfcs->process->pid;
1118#endif //0
1119 value = lttv_attribute_add(tracefile_tree, LTTV_STATE_EVENT,
1120 LTTV_POINTER);
1121 /* Only save the position if the tfs has not infinite time. */
1122 //if(!g_tree_lookup(self->parent.ts_context->pqueue, &tfcs->parent)
1123 // && current_tfcs != tfcs) {
1124 if(ltt_time_compare(tfcs->parent.timestamp, ltt_time_infinite) == 0) {
1125 *(value.v_pointer) = NULL;
1126 } else {
1127 LttEvent *e = ltt_tracefile_get_event(tfcs->parent.tf);
1128 ep = ltt_event_position_new();
1129 ltt_event_position(e, ep);
1130 *(value.v_pointer) = ep;
1131
1132 guint nb_block, offset;
1133 guint64 tsc;
1134 LttTracefile *tf;
1135 ltt_event_position_get(ep, &tf, &nb_block, &offset, &tsc);
1136 g_info("Block %u offset %u tsc %llu time %lu.%lu", nb_block, offset,
1137 tsc,
1138 tfcs->parent.timestamp.tv_sec, tfcs->parent.timestamp.tv_nsec);
1139 }
1140 }
1141}
1142
1143
1144static void state_restore(LttvTraceState *self, LttvAttribute *container)
1145{
1146 guint i, nb_tracefile, pid, nb_cpus;
1147
1148 LttvTracefileState *tfcs;
1149
1150 LttvAttribute *tracefiles_tree, *tracefile_tree;
1151
1152 guint *running_process;
1153
1154 LttvAttributeType type;
1155
1156 LttvAttributeValue value;
1157
1158 LttvAttributeName name;
1159
1160 gboolean is_named;
1161
1162 LttEventPosition *ep;
1163
1164 LttvTracesetContext *tsc = self->parent.ts_context;
1165
1166 tracefiles_tree = lttv_attribute_find_subdir(container,
1167 LTTV_STATE_TRACEFILES);
1168
1169 type = lttv_attribute_get_by_name(container, LTTV_STATE_PROCESSES,
1170 &value);
1171 g_assert(type == LTTV_POINTER);
1172 lttv_state_free_process_table(self->processes);
1173 self->processes = lttv_state_copy_process_table(*(value.v_pointer));
1174
1175 /* Add the currently running processes array */
1176 nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
1177 type = lttv_attribute_get_by_name(container, LTTV_STATE_RUNNING_PROCESS,
1178 &value);
1179 g_assert(type == LTTV_POINTER);
1180 running_process = *(value.v_pointer);
1181 for(i=0;i<nb_cpus;i++) {
1182 pid = running_process[i];
1183 self->running_process[i] = lttv_state_find_process(self, i, pid);
1184 g_assert(self->running_process[i] != NULL);
1185 }
1186
1187
1188 nb_tracefile = self->parent.tracefiles->len;
1189
1190 //g_tree_destroy(tsc->pqueue);
1191 //tsc->pqueue = g_tree_new(compare_tracefile);
1192
1193 for(i = 0 ; i < nb_tracefile ; i++) {
1194 tfcs =
1195 LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
1196 LttvTracefileContext*, i));
1197 type = lttv_attribute_get(tracefiles_tree, i, &name, &value, &is_named);
1198 g_assert(type == LTTV_GOBJECT);
1199 tracefile_tree = *((LttvAttribute **)(value.v_gobject));
1200#if 0
1201 type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_PROCESS,
1202 &value);
1203 g_assert(type == LTTV_UINT);
1204 pid = *(value.v_uint);
1205 tfcs->process = lttv_state_find_process_or_create(tfcs, pid);
1206#endif //0
1207 type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_EVENT,
1208 &value);
1209 g_assert(type == LTTV_POINTER);
1210 //g_assert(*(value.v_pointer) != NULL);
1211 ep = *(value.v_pointer);
1212 g_assert(tfcs->parent.t_context != NULL);
1213
1214 LttvTracefileContext *tfc = LTTV_TRACEFILE_CONTEXT(tfcs);
1215 g_tree_remove(tsc->pqueue, tfc);
1216
1217 if(ep != NULL) {
1218 g_assert(ltt_tracefile_seek_position(tfc->tf, ep) == 0);
1219 tfc->timestamp = ltt_event_time(ltt_tracefile_get_event(tfc->tf));
1220 g_assert(ltt_time_compare(tfc->timestamp, ltt_time_infinite) != 0);
1221 g_tree_insert(tsc->pqueue, tfc, tfc);
1222 g_info("Restoring state for a tf at time %lu.%lu", tfc->timestamp.tv_sec, tfc->timestamp.tv_nsec);
1223 } else {
1224 tfc->timestamp = ltt_time_infinite;
1225 }
1226 }
1227}
1228
1229
1230static void state_saved_free(LttvTraceState *self, LttvAttribute *container)
1231{
1232 guint i, nb_tracefile, nb_cpus;
1233
1234 LttvTracefileState *tfcs;
1235
1236 LttvAttribute *tracefiles_tree, *tracefile_tree;
1237
1238 guint *running_process;
1239
1240 LttvAttributeType type;
1241
1242 LttvAttributeValue value;
1243
1244 LttvAttributeName name;
1245
1246 gboolean is_named;
1247
1248 LttEventPosition *ep;
1249
1250 tracefiles_tree = lttv_attribute_find_subdir(container,
1251 LTTV_STATE_TRACEFILES);
1252 g_object_ref(G_OBJECT(tracefiles_tree));
1253 lttv_attribute_remove_by_name(container, LTTV_STATE_TRACEFILES);
1254
1255 type = lttv_attribute_get_by_name(container, LTTV_STATE_PROCESSES,
1256 &value);
1257 g_assert(type == LTTV_POINTER);
1258 lttv_state_free_process_table(*(value.v_pointer));
1259 *(value.v_pointer) = NULL;
1260 lttv_attribute_remove_by_name(container, LTTV_STATE_PROCESSES);
1261
1262 /* Free running processes array */
1263 nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
1264 type = lttv_attribute_get_by_name(container, LTTV_STATE_RUNNING_PROCESS,
1265 &value);
1266 g_assert(type == LTTV_POINTER);
1267 running_process = *(value.v_pointer);
1268 g_free(running_process);
1269
1270 nb_tracefile = self->parent.tracefiles->len;
1271
1272 for(i = 0 ; i < nb_tracefile ; i++) {
1273 tfcs =
1274 LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
1275 LttvTracefileContext*, i));
1276 type = lttv_attribute_get(tracefiles_tree, i, &name, &value, &is_named);
1277 g_assert(type == LTTV_GOBJECT);
1278 tracefile_tree = *((LttvAttribute **)(value.v_gobject));
1279
1280 type = lttv_attribute_get_by_name(tracefile_tree, LTTV_STATE_EVENT,
1281 &value);
1282 g_assert(type == LTTV_POINTER);
1283 if(*(value.v_pointer) != NULL) g_free(*(value.v_pointer));
1284 }
1285 g_object_unref(G_OBJECT(tracefiles_tree));
1286}
1287
1288
1289static void free_saved_state(LttvTraceState *self)
1290{
1291 guint i, nb;
1292
1293 LttvAttributeType type;
1294
1295 LttvAttributeValue value;
1296
1297 LttvAttributeName name;
1298
1299 gboolean is_named;
1300
1301 LttvAttribute *saved_states;
1302
1303 saved_states = lttv_attribute_find_subdir(self->parent.t_a,
1304 LTTV_STATE_SAVED_STATES);
1305
1306 nb = lttv_attribute_get_number(saved_states);
1307 for(i = 0 ; i < nb ; i++) {
1308 type = lttv_attribute_get(saved_states, i, &name, &value, &is_named);
1309 g_assert(type == LTTV_GOBJECT);
1310 state_saved_free(self, *((LttvAttribute **)value.v_gobject));
1311 }
1312
1313 lttv_attribute_remove_by_name(self->parent.t_a, LTTV_STATE_SAVED_STATES);
1314}
1315
1316
1317static void
1318create_max_time(LttvTraceState *tcs)
1319{
1320 LttvAttributeValue v;
1321
1322 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_SAVED_STATES_TIME,
1323 LTTV_POINTER, &v);
1324 g_assert(*(v.v_pointer) == NULL);
1325 *(v.v_pointer) = g_new(LttTime,1);
1326 *((LttTime *)*(v.v_pointer)) = ltt_time_zero;
1327}
1328
1329
1330static void
1331get_max_time(LttvTraceState *tcs)
1332{
1333 LttvAttributeValue v;
1334
1335 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_SAVED_STATES_TIME,
1336 LTTV_POINTER, &v);
1337 g_assert(*(v.v_pointer) != NULL);
1338 tcs->max_time_state_recomputed_in_seek = (LttTime *)*(v.v_pointer);
1339}
1340
1341
1342static void
1343free_max_time(LttvTraceState *tcs)
1344{
1345 LttvAttributeValue v;
1346
1347 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_SAVED_STATES_TIME,
1348 LTTV_POINTER, &v);
1349 g_free(*(v.v_pointer));
1350 *(v.v_pointer) = NULL;
1351}
1352
1353
1354typedef struct _LttvNameTables {
1355 // FIXME GQuark *eventtype_names;
1356 GQuark *syscall_names;
1357 guint nb_syscalls;
1358 GQuark *trap_names;
1359 guint nb_traps;
1360 GQuark *irq_names;
1361 guint nb_irqs;
1362 GQuark *soft_irq_names;
1363 guint nb_softirqs;
1364} LttvNameTables;
1365
1366
1367static void
1368create_name_tables(LttvTraceState *tcs)
1369{
1370 int i, nb;
1371
1372 GQuark f_name, e_name;
1373
1374 LttvTraceHook h;
1375
1376 LttvTraceHookByFacility *thf;
1377
1378 LttEventType *et;
1379
1380 LttType *t;
1381
1382 GString *fe_name = g_string_new("");
1383
1384 LttvNameTables *name_tables = g_new(LttvNameTables, 1);
1385
1386 LttvAttributeValue v;
1387
1388 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
1389 LTTV_POINTER, &v);
1390 g_assert(*(v.v_pointer) == NULL);
1391 *(v.v_pointer) = name_tables;
1392#if 0 // Use iteration over the facilities_by_name and then list all event
1393 // types of each facility
1394 nb = ltt_trace_eventtype_number(tcs->parent.t);
1395 name_tables->eventtype_names = g_new(GQuark, nb);
1396 for(i = 0 ; i < nb ; i++) {
1397 et = ltt_trace_eventtype_get(tcs->parent.t, i);
1398 e_name = ltt_eventtype_name(et);
1399 f_name = ltt_facility_name(ltt_eventtype_facility(et));
1400 g_string_printf(fe_name, "%s.%s", f_name, e_name);
1401 name_tables->eventtype_names[i] = g_quark_from_string(fe_name->str);
1402 }
1403#endif //0
1404 if(!lttv_trace_find_hook(tcs->parent.t,
1405 LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY,
1406 LTT_FIELD_SYSCALL_ID, 0, 0,
1407 NULL, NULL, &h)) {
1408
1409 thf = lttv_trace_hook_get_first(&h);
1410
1411 t = ltt_field_type(thf->f1);
1412 nb = ltt_type_element_number(t);
1413
1414 lttv_trace_hook_destroy(&h);
1415
1416 name_tables->syscall_names = g_new(GQuark, nb);
1417 name_tables->nb_syscalls = nb;
1418
1419 for(i = 0 ; i < nb ; i++) {
1420 name_tables->syscall_names[i] = ltt_enum_string_get(t, i);
1421 if(!name_tables->syscall_names[i]) {
1422 GString *string = g_string_new("");
1423 g_string_printf(string, "syscall %u", i);
1424 name_tables->syscall_names[i] = g_quark_from_string(string->str);
1425 g_string_free(string, TRUE);
1426 }
1427 }
1428
1429 //name_tables->syscall_names = g_new(GQuark, 256);
1430 //for(i = 0 ; i < 256 ; i++) {
1431 // g_string_printf(fe_name, "syscall %d", i);
1432 // name_tables->syscall_names[i] = g_quark_from_string(fe_name->str);
1433 //}
1434 } else {
1435 name_tables->syscall_names = NULL;
1436 name_tables->nb_syscalls = 0;
1437 }
1438
1439 if(!lttv_trace_find_hook(tcs->parent.t, LTT_FACILITY_KERNEL,
1440 LTT_EVENT_TRAP_ENTRY,
1441 LTT_FIELD_TRAP_ID, 0, 0,
1442 NULL, NULL, &h)) {
1443
1444 thf = lttv_trace_hook_get_first(&h);
1445
1446 t = ltt_field_type(thf->f1);
1447 //nb = ltt_type_element_number(t);
1448
1449 lttv_trace_hook_destroy(&h);
1450
1451 /*
1452 name_tables->trap_names = g_new(GQuark, nb);
1453 for(i = 0 ; i < nb ; i++) {
1454 name_tables->trap_names[i] = g_quark_from_string(
1455 ltt_enum_string_get(t, i));
1456 }
1457 */
1458 name_tables->nb_traps = 256;
1459 name_tables->trap_names = g_new(GQuark, 256);
1460 for(i = 0 ; i < 256 ; i++) {
1461 g_string_printf(fe_name, "trap %d", i);
1462 name_tables->trap_names[i] = g_quark_from_string(fe_name->str);
1463 }
1464 } else {
1465 name_tables->trap_names = NULL;
1466 name_tables->nb_traps = 0;
1467 }
1468
1469 if(!lttv_trace_find_hook(tcs->parent.t,
1470 LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY,
1471 LTT_FIELD_IRQ_ID, 0, 0,
1472 NULL, NULL, &h)) {
1473
1474 thf = lttv_trace_hook_get_first(&h);
1475
1476 t = ltt_field_type(thf->f1);
1477 //nb = ltt_type_element_number(t);
1478
1479 lttv_trace_hook_destroy(&h);
1480
1481 /*
1482 name_tables->irq_names = g_new(GQuark, nb);
1483 for(i = 0 ; i < nb ; i++) {
1484 name_tables->irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
1485 }
1486 */
1487
1488 name_tables->nb_irqs = 256;
1489 name_tables->irq_names = g_new(GQuark, 256);
1490 for(i = 0 ; i < 256 ; i++) {
1491 g_string_printf(fe_name, "irq %d", i);
1492 name_tables->irq_names[i] = g_quark_from_string(fe_name->str);
1493 }
1494 } else {
1495 name_tables->nb_irqs = 0;
1496 name_tables->irq_names = NULL;
1497 }
1498 /*
1499 name_tables->soft_irq_names = g_new(GQuark, nb);
1500 for(i = 0 ; i < nb ; i++) {
1501 name_tables->soft_irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
1502 }
1503 */
1504
1505 name_tables->nb_softirqs = 256;
1506 name_tables->soft_irq_names = g_new(GQuark, 256);
1507 for(i = 0 ; i < 256 ; i++) {
1508 g_string_printf(fe_name, "softirq %d", i);
1509 name_tables->soft_irq_names[i] = g_quark_from_string(fe_name->str);
1510 }
1511
1512
1513 g_string_free(fe_name, TRUE);
1514}
1515
1516
1517static void
1518get_name_tables(LttvTraceState *tcs)
1519{
1520 LttvNameTables *name_tables;
1521
1522 LttvAttributeValue v;
1523
1524 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
1525 LTTV_POINTER, &v);
1526 g_assert(*(v.v_pointer) != NULL);
1527 name_tables = (LttvNameTables *)*(v.v_pointer);
1528 //tcs->eventtype_names = name_tables->eventtype_names;
1529 tcs->syscall_names = name_tables->syscall_names;
1530 tcs->nb_syscalls = name_tables->nb_syscalls;
1531 tcs->trap_names = name_tables->trap_names;
1532 tcs->nb_traps = name_tables->nb_traps;
1533 tcs->irq_names = name_tables->irq_names;
1534 tcs->soft_irq_names = name_tables->soft_irq_names;
1535 tcs->nb_irqs = name_tables->nb_irqs;
1536 tcs->nb_softirqs = name_tables->nb_softirqs;
1537}
1538
1539
1540static void
1541free_name_tables(LttvTraceState *tcs)
1542{
1543 LttvNameTables *name_tables;
1544
1545 LttvAttributeValue v;
1546
1547 lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
1548 LTTV_POINTER, &v);
1549 name_tables = (LttvNameTables *)*(v.v_pointer);
1550 *(v.v_pointer) = NULL;
1551
1552 // g_free(name_tables->eventtype_names);
1553 if(name_tables->syscall_names) g_free(name_tables->syscall_names);
1554 if(name_tables->trap_names) g_free(name_tables->trap_names);
1555 if(name_tables->irq_names) g_free(name_tables->irq_names);
1556 if(name_tables->soft_irq_names) g_free(name_tables->soft_irq_names);
1557 if(name_tables) g_free(name_tables);
1558}
1559
1560#ifdef HASH_TABLE_DEBUG
1561
1562static void test_process(gpointer key, gpointer value, gpointer user_data)
1563{
1564 LttvProcessState *process = (LttvProcessState *)value;
1565
1566 /* Test for process corruption */
1567 guint stack_len = process->execution_stack->len;
1568}
1569
1570static void hash_table_check(GHashTable *table)
1571{
1572 g_hash_table_foreach(table, test_process, NULL);
1573}
1574
1575
1576#endif
1577
1578
1579static void push_state(LttvTracefileState *tfs, LttvExecutionMode t,
1580 guint state_id)
1581{
1582 LttvExecutionState *es;
1583
1584 LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
1585 guint cpu = tfs->cpu;
1586
1587#ifdef HASH_TABLE_DEBUG
1588 hash_table_check(ts->processes);
1589#endif
1590 LttvProcessState *process = ts->running_process[cpu];
1591
1592 guint depth = process->execution_stack->len;
1593
1594 process->execution_stack =
1595 g_array_set_size(process->execution_stack, depth + 1);
1596 /* Keep in sync */
1597 process->state =
1598 &g_array_index(process->execution_stack, LttvExecutionState, depth - 1);
1599
1600 es = &g_array_index(process->execution_stack, LttvExecutionState, depth);
1601 es->t = t;
1602 es->n = state_id;
1603 es->entry = es->change = tfs->parent.timestamp;
1604 es->cum_cpu_time = ltt_time_zero;
1605 es->s = process->state->s;
1606 process->state = es;
1607}
1608
1609/* pop state
1610 * return 1 when empty, else 0 */
1611int lttv_state_pop_state_cleanup(LttvProcessState *process,
1612 LttvTracefileState *tfs)
1613{
1614 guint cpu = tfs->cpu;
1615 LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
1616
1617 guint depth = process->execution_stack->len;
1618
1619 if(depth == 1){
1620 return 1;
1621 }
1622
1623 process->execution_stack =
1624 g_array_set_size(process->execution_stack, depth - 1);
1625 process->state = &g_array_index(process->execution_stack, LttvExecutionState,
1626 depth - 2);
1627 process->state->change = tfs->parent.timestamp;
1628
1629 return 0;
1630}
1631
1632static void pop_state(LttvTracefileState *tfs, LttvExecutionMode t)
1633{
1634 guint cpu = tfs->cpu;
1635 LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
1636 LttvProcessState *process = ts->running_process[cpu];
1637
1638 guint depth = process->execution_stack->len;
1639
1640 if(process->state->t != t){
1641 g_info("Different execution mode type (%lu.%09lu): ignore it\n",
1642 tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
1643 g_info("process state has %s when pop_int is %s\n",
1644 g_quark_to_string(process->state->t),
1645 g_quark_to_string(t));
1646 g_info("{ %u, %u, %s, %s, %s }\n",
1647 process->pid,
1648 process->ppid,
1649 g_quark_to_string(process->name),
1650 g_quark_to_string(process->brand),
1651 g_quark_to_string(process->state->s));
1652 return;
1653 }
1654
1655 if(depth == 1){
1656 g_info("Trying to pop last state on stack (%lu.%09lu): ignore it\n",
1657 tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
1658 return;
1659 }
1660
1661 process->execution_stack =
1662 g_array_set_size(process->execution_stack, depth - 1);
1663 process->state = &g_array_index(process->execution_stack, LttvExecutionState,
1664 depth - 2);
1665 process->state->change = tfs->parent.timestamp;
1666}
1667
1668struct search_result {
1669 const LttTime *time; /* Requested time */
1670 LttTime *best; /* Best result */
1671};
1672
1673static gint search_usertrace(gconstpointer a, gconstpointer b)
1674{
1675 const LttTime *elem_time = (const LttTime*)a;
1676 /* Explicit non const cast */
1677 struct search_result *res = (struct search_result *)b;
1678
1679 if(ltt_time_compare(*elem_time, *(res->time)) < 0) {
1680 /* The usertrace was created before the schedchange */
1681 /* Get larger keys */
1682 return 1;
1683 } else if(ltt_time_compare(*elem_time, *(res->time)) >= 0) {
1684 /* The usertrace was created after the schedchange time */
1685 /* Get smaller keys */
1686 if(res->best) {
1687 if(ltt_time_compare(*elem_time, *res->best) < 0) {
1688 res->best = elem_time;
1689 }
1690 } else {
1691 res->best = elem_time;
1692 }
1693 return -1;
1694 }
1695 return 0;
1696}
1697
1698static LttvTracefileState *ltt_state_usertrace_find(LttvTraceState *tcs,
1699 guint pid, const LttTime *timestamp)
1700{
1701 LttvTracefileState *tfs = NULL;
1702 struct search_result res;
1703 /* Find the usertrace associated with a pid and time interval.
1704 * Search in the usertraces by PID (within a hash) and then, for each
1705 * corresponding element of the array, find the first one with creation
1706 * timestamp the lowest, but higher or equal to "timestamp". */
1707 res.time = timestamp;
1708 res.best = NULL;
1709 GTree *usertrace_tree = g_hash_table_lookup(tcs->usertraces, (gpointer)pid);
1710 if(usertrace_tree) {
1711 g_tree_search(usertrace_tree, search_usertrace, &res);
1712 if(res.best)
1713 tfs = g_tree_lookup(usertrace_tree, res.best);
1714 }
1715
1716 return tfs;
1717}
1718
1719
1720LttvProcessState *
1721lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent,
1722 guint cpu, guint pid, guint tgid, GQuark name, const LttTime *timestamp)
1723{
1724 LttvProcessState *process = g_new(LttvProcessState, 1);
1725
1726 LttvExecutionState *es;
1727
1728 LttvTraceContext *tc = (LttvTraceContext*)tcs;
1729
1730 char buffer[128];
1731
1732 process->pid = pid;
1733 process->tgid = tgid;
1734 process->cpu = cpu;
1735 process->name = name;
1736 process->brand = LTTV_STATE_UNBRANDED;
1737 //process->last_cpu = tfs->cpu_name;
1738 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
1739 process->type = LTTV_STATE_USER_THREAD;
1740 process->usertrace = ltt_state_usertrace_find(tcs, pid, timestamp);
1741 process->current_function = 0; //function 0x0 by default.
1742
1743 g_info("Process %u, core %p", process->pid, process);
1744 g_hash_table_insert(tcs->processes, process, process);
1745
1746 if(parent) {
1747 process->ppid = parent->pid;
1748 process->creation_time = *timestamp;
1749 }
1750
1751 /* No parent. This process exists but we are missing all information about
1752 its creation. The birth time is set to zero but we remember the time of
1753 insertion */
1754
1755 else {
1756 process->ppid = 0;
1757 process->creation_time = ltt_time_zero;
1758 }
1759
1760 process->insertion_time = *timestamp;
1761 sprintf(buffer,"%d-%lu.%lu",pid, process->creation_time.tv_sec,
1762 process->creation_time.tv_nsec);
1763 process->pid_time = g_quark_from_string(buffer);
1764 process->cpu = cpu;
1765 //process->last_cpu = tfs->cpu_name;
1766 //process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
1767 process->execution_stack = g_array_sized_new(FALSE, FALSE,
1768 sizeof(LttvExecutionState), PREALLOCATED_EXECUTION_STACK);
1769 process->execution_stack = g_array_set_size(process->execution_stack, 2);
1770 es = process->state = &g_array_index(process->execution_stack,
1771 LttvExecutionState, 0);
1772 es->t = LTTV_STATE_USER_MODE;
1773 es->n = LTTV_STATE_SUBMODE_NONE;
1774 es->entry = *timestamp;
1775 //g_assert(timestamp->tv_sec != 0);
1776 es->change = *timestamp;
1777 es->cum_cpu_time = ltt_time_zero;
1778 es->s = LTTV_STATE_RUN;
1779
1780 es = process->state = &g_array_index(process->execution_stack,
1781 LttvExecutionState, 1);
1782 es->t = LTTV_STATE_SYSCALL;
1783 es->n = LTTV_STATE_SUBMODE_NONE;
1784 es->entry = *timestamp;
1785 //g_assert(timestamp->tv_sec != 0);
1786 es->change = *timestamp;
1787 es->cum_cpu_time = ltt_time_zero;
1788 es->s = LTTV_STATE_WAIT_FORK;
1789
1790 /* Allocate an empty function call stack. If it's empty, use 0x0. */
1791 process->user_stack = g_array_sized_new(FALSE, FALSE,
1792 sizeof(guint64), 0);
1793
1794 return process;
1795}
1796
1797LttvProcessState *lttv_state_find_process(LttvTraceState *ts, guint cpu,
1798 guint pid)
1799{
1800 LttvProcessState key;
1801 LttvProcessState *process;
1802
1803 key.pid = pid;
1804 key.cpu = cpu;
1805 process = g_hash_table_lookup(ts->processes, &key);
1806 return process;
1807}
1808
1809LttvProcessState *
1810lttv_state_find_process_or_create(LttvTraceState *ts, guint cpu, guint pid,
1811 const LttTime *timestamp)
1812{
1813 LttvProcessState *process = lttv_state_find_process(ts, cpu, pid);
1814 LttvExecutionState *es;
1815
1816 /* Put ltt_time_zero creation time for unexisting processes */
1817 if(unlikely(process == NULL)) {
1818 process = lttv_state_create_process(ts,
1819 NULL, cpu, pid, 0, LTTV_STATE_UNNAMED, timestamp);
1820 /* We are not sure is it's a kernel thread or normal thread, put the
1821 * bottom stack state to unknown */
1822 process->execution_stack =
1823 g_array_set_size(process->execution_stack, 1);
1824 process->state = es =
1825 &g_array_index(process->execution_stack, LttvExecutionState, 0);
1826 es->t = LTTV_STATE_MODE_UNKNOWN;
1827 es->s = LTTV_STATE_UNNAMED;
1828 }
1829 return process;
1830}
1831
1832/* FIXME : this function should be called when we receive an event telling that
1833 * release_task has been called in the kernel. In happens generally when
1834 * the parent waits for its child terminaison, but may also happen in special
1835 * cases in the child's exit : when the parent ignores its children SIGCCHLD or
1836 * has the flag SA_NOCLDWAIT. It can also happen when the child is part
1837 * of a killed thread ground, but isn't the leader.
1838 */
1839static void exit_process(LttvTracefileState *tfs, LttvProcessState *process)
1840{
1841 LttvTraceState *ts = LTTV_TRACE_STATE(tfs->parent.t_context);
1842 LttvProcessState key;
1843
1844 key.pid = process->pid;
1845 key.cpu = process->cpu;
1846 g_hash_table_remove(ts->processes, &key);
1847 g_array_free(process->execution_stack, TRUE);
1848 g_array_free(process->user_stack, TRUE);
1849 g_free(process);
1850}
1851
1852
1853static void free_process_state(gpointer key, gpointer value,gpointer user_data)
1854{
1855 g_array_free(((LttvProcessState *)value)->execution_stack, TRUE);
1856 g_array_free(((LttvProcessState *)value)->user_stack, TRUE);
1857 g_free(value);
1858}
1859
1860
1861static void lttv_state_free_process_table(GHashTable *processes)
1862{
1863 g_hash_table_foreach(processes, free_process_state, NULL);
1864 g_hash_table_destroy(processes);
1865}
1866
1867
1868static gboolean syscall_entry(void *hook_data, void *call_data)
1869{
1870 LttvTracefileState *s = (LttvTracefileState *)call_data;
1871 guint cpu = s->cpu;
1872 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
1873 LttvProcessState *process = ts->running_process[cpu];
1874 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1875 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1876 LttField *f = thf->f1;
1877
1878 LttvExecutionSubmode submode;
1879
1880 guint nb_syscalls = ((LttvTraceState *)(s->parent.t_context))->nb_syscalls;
1881 guint syscall = ltt_event_get_unsigned(e, f);
1882
1883 if(syscall < nb_syscalls) {
1884 submode = ((LttvTraceState *)(s->parent.t_context))->syscall_names[
1885 syscall];
1886 } else {
1887 /* Fixup an incomplete syscall table */
1888 GString *string = g_string_new("");
1889 g_string_printf(string, "syscall %u", syscall);
1890 submode = g_quark_from_string(string->str);
1891 g_string_free(string, TRUE);
1892 }
1893 /* There can be no system call from PID 0 : unknown state */
1894 if(process->pid != 0)
1895 push_state(s, LTTV_STATE_SYSCALL, submode);
1896 return FALSE;
1897}
1898
1899
1900static gboolean syscall_exit(void *hook_data, void *call_data)
1901{
1902 LttvTracefileState *s = (LttvTracefileState *)call_data;
1903 guint cpu = s->cpu;
1904 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
1905 LttvProcessState *process = ts->running_process[cpu];
1906
1907 /* There can be no system call from PID 0 : unknown state */
1908 if(process->pid != 0)
1909 pop_state(s, LTTV_STATE_SYSCALL);
1910 return FALSE;
1911}
1912
1913
1914static gboolean trap_entry(void *hook_data, void *call_data)
1915{
1916 LttvTracefileState *s = (LttvTracefileState *)call_data;
1917 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1918 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1919 LttField *f = thf->f1;
1920
1921 LttvExecutionSubmode submode;
1922
1923 guint64 nb_traps = ((LttvTraceState *)(s->parent.t_context))->nb_traps;
1924 guint64 trap = ltt_event_get_long_unsigned(e, f);
1925
1926 if(trap < nb_traps) {
1927 submode = ((LttvTraceState *)(s->parent.t_context))->trap_names[trap];
1928 } else {
1929 /* Fixup an incomplete trap table */
1930 GString *string = g_string_new("");
1931 g_string_printf(string, "trap %llu", trap);
1932 submode = g_quark_from_string(string->str);
1933 g_string_free(string, TRUE);
1934 }
1935
1936 push_state(s, LTTV_STATE_TRAP, submode);
1937 return FALSE;
1938}
1939
1940
1941static gboolean trap_exit(void *hook_data, void *call_data)
1942{
1943 LttvTracefileState *s = (LttvTracefileState *)call_data;
1944
1945 pop_state(s, LTTV_STATE_TRAP);
1946 return FALSE;
1947}
1948
1949
1950static gboolean irq_entry(void *hook_data, void *call_data)
1951{
1952 LttvTracefileState *s = (LttvTracefileState *)call_data;
1953 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
1954 guint8 fac_id = ltt_event_facility_id(e);
1955 guint8 ev_id = ltt_event_eventtype_id(e);
1956 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
1957 // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
1958 g_assert(thf->f1 != NULL);
1959 // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
1960 LttField *f = thf->f1;
1961
1962 LttvExecutionSubmode submode;
1963 guint64 irq = ltt_event_get_long_unsigned(e, f);
1964 guint64 nb_irqs = ((LttvTraceState *)(s->parent.t_context))->nb_irqs;
1965 GString *string;
1966
1967 if(irq < nb_irqs) {
1968 submode = ((LttvTraceState *)(s->parent.t_context))->irq_names[irq];
1969 } else {
1970 /* Fixup an incomplete irq table */
1971 GString *string = g_string_new("");
1972 g_string_printf(string, "irq %llu", irq);
1973 submode = g_quark_from_string(string->str);
1974 g_string_free(string, TRUE);
1975 }
1976
1977 /* Do something with the info about being in user or system mode when int? */
1978 push_state(s, LTTV_STATE_IRQ, submode);
1979 return FALSE;
1980}
1981
1982static gboolean soft_irq_exit(void *hook_data, void *call_data)
1983{
1984 LttvTracefileState *s = (LttvTracefileState *)call_data;
1985
1986 pop_state(s, LTTV_STATE_SOFT_IRQ);
1987 return FALSE;
1988}
1989
1990
1991
1992static gboolean irq_exit(void *hook_data, void *call_data)
1993{
1994 LttvTracefileState *s = (LttvTracefileState *)call_data;
1995
1996 pop_state(s, LTTV_STATE_IRQ);
1997 return FALSE;
1998}
1999
2000static gboolean soft_irq_entry(void *hook_data, void *call_data)
2001{
2002 LttvTracefileState *s = (LttvTracefileState *)call_data;
2003 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2004 guint8 fac_id = ltt_event_facility_id(e);
2005 guint8 ev_id = ltt_event_eventtype_id(e);
2006 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2007 // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
2008 g_assert(thf->f1 != NULL);
2009 // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
2010 LttField *f = thf->f1;
2011
2012 LttvExecutionSubmode submode;
2013 guint64 softirq = ltt_event_get_long_unsigned(e, f);
2014 guint64 nb_softirqs = ((LttvTraceState *)(s->parent.t_context))->nb_softirqs;
2015 GString *string;
2016
2017 if(softirq < nb_softirqs) {
2018 submode = ((LttvTraceState *)(s->parent.t_context))->soft_irq_names[softirq];
2019 } else {
2020 /* Fixup an incomplete irq table */
2021 GString *string = g_string_new("");
2022 g_string_printf(string, "softirq %llu", softirq);
2023 submode = g_quark_from_string(string->str);
2024 g_string_free(string, TRUE);
2025 }
2026
2027 /* Do something with the info about being in user or system mode when int? */
2028 push_state(s, LTTV_STATE_SOFT_IRQ, submode);
2029 return FALSE;
2030}
2031
2032static void push_function(LttvTracefileState *tfs, guint64 funcptr)
2033{
2034 guint64 *new_func;
2035
2036 LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
2037 guint cpu = tfs->cpu;
2038 LttvProcessState *process = ts->running_process[cpu];
2039
2040 guint depth = process->user_stack->len;
2041
2042 process->user_stack =
2043 g_array_set_size(process->user_stack, depth + 1);
2044
2045 new_func = &g_array_index(process->user_stack, guint64, depth);
2046 *new_func = funcptr;
2047 process->current_function = funcptr;
2048}
2049
2050static void pop_function(LttvTracefileState *tfs, guint64 funcptr)
2051{
2052 guint cpu = tfs->cpu;
2053 LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
2054 LttvProcessState *process = ts->running_process[cpu];
2055
2056 if(process->current_function != funcptr){
2057 g_info("Different functions (%lu.%09lu): ignore it\n",
2058 tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
2059 g_info("process state has %llu when pop_function is %llu\n",
2060 process->current_function, funcptr);
2061 g_info("{ %u, %u, %s, %s, %s }\n",
2062 process->pid,
2063 process->ppid,
2064 g_quark_to_string(process->name),
2065 g_quark_to_string(process->brand),
2066 g_quark_to_string(process->state->s));
2067 return;
2068 }
2069 guint depth = process->user_stack->len;
2070
2071 if(depth == 0){
2072 g_info("Trying to pop last function on stack (%lu.%09lu): ignore it\n",
2073 tfs->parent.timestamp.tv_sec, tfs->parent.timestamp.tv_nsec);
2074 return;
2075 }
2076
2077 process->user_stack =
2078 g_array_set_size(process->user_stack, depth - 1);
2079 process->current_function =
2080 g_array_index(process->user_stack, guint64, depth - 2);
2081}
2082
2083
2084static gboolean function_entry(void *hook_data, void *call_data)
2085{
2086 LttvTracefileState *s = (LttvTracefileState *)call_data;
2087 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2088 guint8 fac_id = ltt_event_facility_id(e);
2089 guint8 ev_id = ltt_event_eventtype_id(e);
2090 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2091 g_assert(thf->f1 != NULL);
2092 LttField *f = thf->f1;
2093 guint64 funcptr = ltt_event_get_long_unsigned(e, f);
2094
2095 push_function(s, funcptr);
2096 return FALSE;
2097}
2098
2099static gboolean function_exit(void *hook_data, void *call_data)
2100{
2101 LttvTracefileState *s = (LttvTracefileState *)call_data;
2102 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2103 guint8 fac_id = ltt_event_facility_id(e);
2104 guint8 ev_id = ltt_event_eventtype_id(e);
2105 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2106 g_assert(thf->f1 != NULL);
2107 LttField *f = thf->f1;
2108 guint64 funcptr = ltt_event_get_long_unsigned(e, f);
2109
2110 LttvExecutionSubmode submode;
2111
2112 pop_function(s, funcptr);
2113 return FALSE;
2114}
2115
2116static gboolean schedchange(void *hook_data, void *call_data)
2117{
2118 LttvTracefileState *s = (LttvTracefileState *)call_data;
2119 guint cpu = s->cpu;
2120 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2121 LttvProcessState *process = ts->running_process[cpu];
2122 LttvProcessState *old_process = ts->running_process[cpu];
2123
2124 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2125 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2126 guint pid_in, pid_out;
2127 gint state_out;
2128
2129 pid_out = ltt_event_get_unsigned(e, thf->f1);
2130 pid_in = ltt_event_get_unsigned(e, thf->f2);
2131 state_out = ltt_event_get_int(e, thf->f3);
2132
2133 if(likely(process != NULL)) {
2134
2135 /* We could not know but it was not the idle process executing.
2136 This should only happen at the beginning, before the first schedule
2137 event, and when the initial information (current process for each CPU)
2138 is missing. It is not obvious how we could, after the fact, compensate
2139 the wrongly attributed statistics. */
2140
2141 //This test only makes sense once the state is known and if there is no
2142 //missing events. We need to silently ignore schedchange coming after a
2143 //process_free, or it causes glitches. (FIXME)
2144 //if(unlikely(process->pid != pid_out)) {
2145 // g_assert(process->pid == 0);
2146 //}
2147 if(process->pid == 0
2148 && process->state->t == LTTV_STATE_MODE_UNKNOWN) {
2149 if(pid_out == 0) {
2150 /* Scheduling out of pid 0 at beginning of the trace :
2151 * we know for sure it is in syscall mode at this point. */
2152 g_assert(process->execution_stack->len == 1);
2153 process->state->t = LTTV_STATE_SYSCALL;
2154 process->state->s = LTTV_STATE_WAIT;
2155 process->state->change = s->parent.timestamp;
2156 process->state->entry = s->parent.timestamp;
2157 }
2158 } else {
2159 if(unlikely(process->state->s == LTTV_STATE_EXIT)) {
2160 process->state->s = LTTV_STATE_ZOMBIE;
2161 process->state->change = s->parent.timestamp;
2162 } else {
2163 if(unlikely(state_out == 0)) process->state->s = LTTV_STATE_WAIT_CPU;
2164 else process->state->s = LTTV_STATE_WAIT;
2165 process->state->change = s->parent.timestamp;
2166 }
2167
2168 if(state_out == 32)
2169 exit_process(s, process); /* EXIT_DEAD */
2170 /* see sched.h for states */
2171 }
2172 }
2173 process = ts->running_process[cpu] =
2174 lttv_state_find_process_or_create(
2175 (LttvTraceState*)s->parent.t_context,
2176 cpu, pid_in,
2177 &s->parent.timestamp);
2178 process->state->s = LTTV_STATE_RUN;
2179 process->cpu = cpu;
2180 if(process->usertrace)
2181 process->usertrace->cpu = cpu;
2182 // process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)s)->tf);
2183 process->state->change = s->parent.timestamp;
2184 return FALSE;
2185}
2186
2187static gboolean process_fork(void *hook_data, void *call_data)
2188{
2189 LttvTracefileState *s = (LttvTracefileState *)call_data;
2190 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2191 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2192 guint parent_pid;
2193 guint child_pid; /* In the Linux Kernel, there is one PID per thread. */
2194 guint child_tgid; /* tgid in the Linux kernel is the "real" POSIX PID. */
2195 LttvProcessState *zombie_process;
2196 guint cpu = s->cpu;
2197 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2198 LttvProcessState *process = ts->running_process[cpu];
2199 LttvProcessState *child_process;
2200
2201 /* Parent PID */
2202 parent_pid = ltt_event_get_unsigned(e, thf->f1);
2203
2204 /* Child PID */
2205 child_pid = ltt_event_get_unsigned(e, thf->f2);
2206 s->parent.target_pid = child_pid;
2207
2208 /* Child TGID */
2209 if(thf->f3) child_tgid = ltt_event_get_unsigned(e, thf->f3);
2210 else child_tgid = 0;
2211
2212 /* Mathieu : it seems like the process might have been scheduled in before the
2213 * fork, and, in a rare case, might be the current process. This might happen
2214 * in a SMP case where we don't have enough precision on the clocks.
2215 *
2216 * Test reenabled after precision fixes on time. (Mathieu) */
2217#if 0
2218 zombie_process = lttv_state_find_process(ts, ANY_CPU, child_pid);
2219
2220 if(unlikely(zombie_process != NULL)) {
2221 /* Reutilisation of PID. Only now we are sure that the old PID
2222 * has been released. FIXME : should know when release_task happens instead.
2223 */
2224 guint num_cpus = ltt_trace_get_num_cpu(ts->parent.t);
2225 guint i;
2226 for(i=0; i< num_cpus; i++) {
2227 g_assert(zombie_process != ts->running_process[i]);
2228 }
2229
2230 exit_process(s, zombie_process);
2231 }
2232#endif //0
2233 g_assert(process->pid != child_pid);
2234 // FIXME : Add this test in the "known state" section
2235 // g_assert(process->pid == parent_pid);
2236 child_process = lttv_state_find_process(ts, ANY_CPU, child_pid);
2237 if(child_process == NULL) {
2238 child_process = lttv_state_create_process(ts, process, cpu,
2239 child_pid, child_tgid,
2240 LTTV_STATE_UNNAMED, &s->parent.timestamp);
2241 } else {
2242 /* The process has already been created : due to time imprecision between
2243 * multiple CPUs : it has been scheduled in before creation. Note that we
2244 * shouldn't have this kind of imprecision.
2245 *
2246 * Simply put a correct parent.
2247 */
2248 g_assert(0); /* This is a problematic case : the process has been created
2249 before the fork event */
2250 child_process->ppid = process->pid;
2251 child_process->tgid = child_tgid;
2252 }
2253 g_assert(child_process->name == LTTV_STATE_UNNAMED);
2254 child_process->name = process->name;
2255 child_process->brand = process->brand;
2256
2257 return FALSE;
2258}
2259
2260/* We stamp a newly created process as kernel_thread */
2261static gboolean process_kernel_thread(void *hook_data, void *call_data)
2262{
2263 LttvTracefileState *s = (LttvTracefileState *)call_data;
2264 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2265 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2266 guint pid;
2267 guint cpu = s->cpu;
2268 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2269 LttvProcessState *process;
2270 LttvExecutionState *es;
2271
2272 /* PID */
2273 pid = ltt_event_get_unsigned(e, thf->f1);
2274 s->parent.target_pid = pid;
2275
2276 process = lttv_state_find_process(ts, ANY_CPU, pid);
2277 process->execution_stack =
2278 g_array_set_size(process->execution_stack, 1);
2279 es = process->state =
2280 &g_array_index(process->execution_stack, LttvExecutionState, 0);
2281 es->t = LTTV_STATE_SYSCALL;
2282 process->type = LTTV_STATE_KERNEL_THREAD;
2283
2284 return FALSE;
2285}
2286
2287static gboolean process_exit(void *hook_data, void *call_data)
2288{
2289 LttvTracefileState *s = (LttvTracefileState *)call_data;
2290 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2291 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2292 LttField *f;
2293 guint pid;
2294 guint cpu = s->cpu;
2295 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2296 LttvProcessState *process; // = ts->running_process[cpu];
2297
2298 pid = ltt_event_get_unsigned(e, thf->f1);
2299 s->parent.target_pid = pid;
2300
2301 // FIXME : Add this test in the "known state" section
2302 // g_assert(process->pid == pid);
2303
2304 process = lttv_state_find_process(ts, ANY_CPU, pid);
2305 if(likely(process != NULL)) {
2306 process->state->s = LTTV_STATE_EXIT;
2307 }
2308 return FALSE;
2309}
2310
2311static gboolean process_free(void *hook_data, void *call_data)
2312{
2313 LttvTracefileState *s = (LttvTracefileState *)call_data;
2314 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2315 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2316 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2317 guint release_pid;
2318 LttvProcessState *process;
2319
2320 /* PID of the process to release */
2321 release_pid = ltt_event_get_unsigned(e, thf->f1);
2322 s->parent.target_pid = release_pid;
2323
2324 g_assert(release_pid != 0);
2325
2326 process = lttv_state_find_process(ts, ANY_CPU, release_pid);
2327
2328 if(likely(process != NULL)) {
2329 /* release_task is happening at kernel level : we can now safely release
2330 * the data structure of the process */
2331 //This test is fun, though, as it may happen that
2332 //at time t : CPU 0 : process_free
2333 //at time t+150ns : CPU 1 : schedule out
2334 //Clearly due to time imprecision, we disable it. (Mathieu)
2335 //If this weird case happen, we have no choice but to put the
2336 //Currently running process on the cpu to 0.
2337 //I re-enable it following time precision fixes. (Mathieu)
2338 //Well, in the case where an process is freed by a process on another CPU
2339 //and still scheduled, it happens that this is the schedchange that will
2340 //drop the last reference count. Do not free it here!
2341 guint num_cpus = ltt_trace_get_num_cpu(ts->parent.t);
2342 guint i;
2343 for(i=0; i< num_cpus; i++) {
2344 //g_assert(process != ts->running_process[i]);
2345 if(process == ts->running_process[i]) {
2346 //ts->running_process[i] = lttv_state_find_process(ts, i, 0);
2347 break;
2348 }
2349 }
2350 if(i == num_cpus) /* process is not scheduled */
2351 exit_process(s, process);
2352 }
2353
2354 return FALSE;
2355}
2356
2357
2358static gboolean process_exec(void *hook_data, void *call_data)
2359{
2360 LttvTracefileState *s = (LttvTracefileState *)call_data;
2361 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2362 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2363 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2364 //gchar *name;
2365 guint cpu = s->cpu;
2366 LttvProcessState *process = ts->running_process[cpu];
2367
2368 /* PID of the process to release */
2369 guint64 name_len = ltt_event_field_element_number(e, thf->f1);
2370 //name = ltt_event_get_string(e, thf->f1);
2371 LttField *child = ltt_event_field_element_select(e, thf->f1, 0);
2372 gchar *name_begin =
2373 (gchar*)(ltt_event_data(e)+ltt_event_field_offset(e, child));
2374 gchar *null_term_name = g_new(gchar, name_len+1);
2375 memcpy(null_term_name, name_begin, name_len);
2376 null_term_name[name_len] = '\0';
2377
2378 process->name = g_quark_from_string(null_term_name);
2379 process->brand = LTTV_STATE_UNBRANDED;
2380 g_free(null_term_name);
2381 return FALSE;
2382}
2383
2384static gboolean thread_brand(void *hook_data, void *call_data)
2385{
2386 LttvTracefileState *s = (LttvTracefileState *)call_data;
2387 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2388 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2389 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2390 gchar *name;
2391 guint cpu = s->cpu;
2392 LttvProcessState *process = ts->running_process[cpu];
2393
2394 name = ltt_event_get_string(e, thf->f1);
2395 process->brand = g_quark_from_string(name);
2396
2397 return FALSE;
2398}
2399
2400static void fix_process(gpointer key, gpointer value,
2401 gpointer user_data)
2402{
2403 LttvProcessState *process;
2404 LttvExecutionState *es;
2405 process = (LttvProcessState *)value;
2406 LttvTracefileContext *tfc = (LttvTracefileContext *)user_data;
2407 LttTime *timestamp = (LttTime*)user_data;
2408
2409 if(process->type == LTTV_STATE_KERNEL_THREAD) {
2410 es = &g_array_index(process->execution_stack, LttvExecutionState, 0);
2411 if(es->t == LTTV_STATE_MODE_UNKNOWN) {
2412 es->t = LTTV_STATE_SYSCALL;
2413 es->n = LTTV_STATE_SUBMODE_NONE;
2414 es->entry = *timestamp;
2415 es->change = *timestamp;
2416 es->cum_cpu_time = ltt_time_zero;
2417 if(es->s == LTTV_STATE_UNNAMED)
2418 es->s = LTTV_STATE_WAIT;
2419 }
2420 } else {
2421 es = &g_array_index(process->execution_stack, LttvExecutionState, 0);
2422 if(es->t == LTTV_STATE_MODE_UNKNOWN) {
2423 es->t = LTTV_STATE_USER_MODE;
2424 es->n = LTTV_STATE_SUBMODE_NONE;
2425 es->entry = *timestamp;
2426 //g_assert(timestamp->tv_sec != 0);
2427 es->change = *timestamp;
2428 es->cum_cpu_time = ltt_time_zero;
2429 if(es->s == LTTV_STATE_UNNAMED)
2430 es->s = LTTV_STATE_RUN;
2431
2432 if(process->execution_stack->len == 1) {
2433 /* Still in user mode, means never scheduled */
2434 process->execution_stack =
2435 g_array_set_size(process->execution_stack, 2);
2436 es = process->state = &g_array_index(process->execution_stack,
2437 LttvExecutionState, 1);
2438 es->t = LTTV_STATE_SYSCALL;
2439 es->n = LTTV_STATE_SUBMODE_NONE;
2440 es->entry = *timestamp;
2441 //g_assert(timestamp->tv_sec != 0);
2442 es->change = *timestamp;
2443 es->cum_cpu_time = ltt_time_zero;
2444 es->s = LTTV_STATE_WAIT;
2445 }
2446 }
2447 }
2448}
2449
2450static gboolean statedump_end(void *hook_data, void *call_data)
2451{
2452 LttvTracefileState *s = (LttvTracefileState *)call_data;
2453 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2454 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
2455 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2456 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2457
2458 /* For all processes */
2459 /* if kernel thread, if stack[0] is unknown, set to syscall mode, wait */
2460 /* else, if stack[0] is unknown, set to user mode, running */
2461
2462 g_hash_table_foreach(ts->processes, fix_process, &tfc->timestamp);
2463}
2464
2465static gboolean enum_process_state(void *hook_data, void *call_data)
2466{
2467 LttvTracefileState *s = (LttvTracefileState *)call_data;
2468 LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
2469 //It's slow : optimise later by doing this before reading trace.
2470 LttEventType *et = ltt_event_eventtype(e);
2471 //
2472 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
2473 guint parent_pid;
2474 guint pid;
2475 guint tgid;
2476 gchar * command;
2477 guint cpu = s->cpu;
2478 LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
2479 LttvProcessState *process = ts->running_process[cpu];
2480 LttvProcessState *parent_process;
2481 LttField *f4, *f5, *f6, *f7, *f8;
2482 GQuark type, mode, submode, status;
2483 LttvExecutionState *es;
2484 guint i, nb_cpus;
2485
2486 /* PID */
2487 pid = ltt_event_get_unsigned(e, thf->f1);
2488 s->parent.target_pid = pid;
2489
2490 /* Parent PID */
2491 parent_pid = ltt_event_get_unsigned(e, thf->f2);
2492
2493 /* Command name */
2494 command = ltt_event_get_string(e, thf->f3);
2495
2496 /* type */
2497 f4 = ltt_eventtype_field_by_name(et, LTT_FIELD_TYPE);
2498 type = ltt_enum_string_get(ltt_field_type(f4),
2499 ltt_event_get_unsigned(e, f4));
2500
2501 /* mode */
2502 f5 = ltt_eventtype_field_by_name(et, LTT_FIELD_MODE);
2503 mode = ltt_enum_string_get(ltt_field_type(f5),
2504 ltt_event_get_unsigned(e, f5));
2505
2506 /* submode */
2507 f6 = ltt_eventtype_field_by_name(et, LTT_FIELD_SUBMODE);
2508 submode = ltt_enum_string_get(ltt_field_type(f6),
2509 ltt_event_get_unsigned(e, f6));
2510
2511 /* status */
2512 f7 = ltt_eventtype_field_by_name(et, LTT_FIELD_STATUS);
2513 status = ltt_enum_string_get(ltt_field_type(f7),
2514 ltt_event_get_unsigned(e, f7));
2515
2516 /* TGID */
2517 f8 = ltt_eventtype_field_by_name(et, LTT_FIELD_TGID);
2518 if(f8) tgid = ltt_event_get_unsigned(e, f8);
2519 else tgid = 0;
2520
2521
2522 if(pid == 0) {
2523 nb_cpus = ltt_trace_get_num_cpu(ts->parent.t);
2524 for(i=0; i<nb_cpus; i++) {
2525 process = lttv_state_find_process(ts, i, pid);
2526 g_assert(process != NULL);
2527
2528 process->ppid = parent_pid;
2529 process->tgid = tgid;
2530 process->name = g_quark_from_string(command);
2531 es =
2532 &g_array_index(process->execution_stack, LttvExecutionState, 0);
2533 process->type = LTTV_STATE_KERNEL_THREAD;
2534 }
2535
2536 } else {
2537 /* The process might exist if a process was forked while performing the
2538 * state dump. */
2539 process = lttv_state_find_process(ts, ANY_CPU, pid);
2540 if(process == NULL) {
2541 parent_process = lttv_state_find_process(ts, ANY_CPU, parent_pid);
2542 process = lttv_state_create_process(ts, parent_process, cpu,
2543 pid, tgid, g_quark_from_string(command),
2544 &s->parent.timestamp);
2545
2546 /* Keep the stack bottom : a running user mode */
2547 /* Disabled because of inconsistencies in the current statedump states. */
2548 if(type == LTTV_STATE_KERNEL_THREAD) {
2549 /* Only keep the bottom
2550 * FIXME Kernel thread : can be in syscall or interrupt or trap. */
2551 /* Will cause expected trap when in fact being syscall (even after end of
2552 * statedump event)
2553 * Will cause expected interrupt when being syscall. (only before end of
2554 * statedump event) */
2555 // This will cause a "popping last state on stack, ignoring it."
2556 process->execution_stack = g_array_set_size(process->execution_stack, 1);
2557 es = process->state = &g_array_index(process->execution_stack,
2558 LttvExecutionState, 0);
2559 process->type = LTTV_STATE_KERNEL_THREAD;
2560 es->t = LTTV_STATE_MODE_UNKNOWN;
2561 es->s = LTTV_STATE_UNNAMED;
2562 es->n = LTTV_STATE_SUBMODE_UNKNOWN;
2563 #if 0
2564 es->t = LTTV_STATE_SYSCALL;
2565 es->s = status;
2566 es->n = submode;
2567 #endif //0
2568 } else {
2569 /* User space process :
2570 * bottom : user mode
2571 * either currently running or scheduled out.
2572 * can be scheduled out because interrupted in (user mode or in syscall)
2573 * or because of an explicit call to the scheduler in syscall. Note that
2574 * the scheduler call comes after the irq_exit, so never in interrupt
2575 * context. */
2576 // temp workaround : set size to 1 : only have user mode bottom of stack.
2577 // will cause g_info message of expected syscall mode when in fact being
2578 // in user mode. Can also cause expected trap when in fact being user
2579 // mode in the event of a page fault reenabling interrupts in the handler.
2580 // Expected syscall and trap can also happen after the end of statedump
2581 // This will cause a "popping last state on stack, ignoring it."
2582 process->execution_stack = g_array_set_size(process->execution_stack, 1);
2583 es = process->state = &g_array_index(process->execution_stack,
2584 LttvExecutionState, 0);
2585 es->t = LTTV_STATE_MODE_UNKNOWN;
2586 es->s = LTTV_STATE_UNNAMED;
2587 es->n = LTTV_STATE_SUBMODE_UNKNOWN;
2588 #if 0
2589 es->t = LTTV_STATE_USER_MODE;
2590 es->s = status;
2591 es->n = submode;
2592 #endif //0
2593 }
2594 #if 0
2595 /* UNKNOWN STATE */
2596 {
2597 es = process->state = &g_array_index(process->execution_stack,
2598 LttvExecutionState, 1);
2599 es->t = LTTV_STATE_MODE_UNKNOWN;
2600 es->s = LTTV_STATE_UNNAMED;
2601 es->n = LTTV_STATE_SUBMODE_UNKNOWN;
2602 }
2603 #endif //0
2604 } else {
2605 /* The process has already been created :
2606 * Probably was forked while dumping the process state or
2607 * was simply scheduled in prior to get the state dump event.
2608 */
2609 process->ppid = parent_pid;
2610 process->tgid = tgid;
2611 process->name = g_quark_from_string(command);
2612 process->type = type;
2613 es =
2614 &g_array_index(process->execution_stack, LttvExecutionState, 0);
2615#if 0
2616 if(es->t == LTTV_STATE_MODE_UNKNOWN) {
2617 if(type == LTTV_STATE_KERNEL_THREAD)
2618 es->t = LTTV_STATE_SYSCALL;
2619 else
2620 es->t = LTTV_STATE_USER_MODE;
2621 }
2622#endif //0
2623 /* Don't mess around with the stack, it will eventually become
2624 * ok after the end of state dump. */
2625 }
2626 }
2627
2628 return FALSE;
2629}
2630
2631gint lttv_state_hook_add_event_hooks(void *hook_data, void *call_data)
2632{
2633 LttvTracesetState *tss = (LttvTracesetState*)(call_data);
2634
2635 lttv_state_add_event_hooks(tss);
2636
2637 return 0;
2638}
2639
2640void lttv_state_add_event_hooks(LttvTracesetState *self)
2641{
2642 LttvTraceset *traceset = self->parent.ts;
2643
2644 guint i, j, k, l, nb_trace, nb_tracefile;
2645
2646 LttvTraceState *ts;
2647
2648 LttvTracefileState *tfs;
2649
2650 GArray *hooks;
2651
2652 LttvTraceHookByFacility *thf;
2653
2654 LttvTraceHook *hook;
2655
2656 LttvAttributeValue val;
2657
2658 gint ret;
2659 gint hn;
2660
2661 nb_trace = lttv_traceset_number(traceset);
2662 for(i = 0 ; i < nb_trace ; i++) {
2663 ts = (LttvTraceState *)self->parent.traces[i];
2664
2665 /* Find the eventtype id for the following events and register the
2666 associated by id hooks. */
2667
2668 hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 19);
2669 hooks = g_array_set_size(hooks, 19); // Max possible number of hooks.
2670 hn = 0;
2671
2672 ret = lttv_trace_find_hook(ts->parent.t,
2673 LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY,
2674 LTT_FIELD_SYSCALL_ID, 0, 0,
2675 syscall_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2676 if(ret) hn--;
2677
2678 ret = lttv_trace_find_hook(ts->parent.t,
2679 LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_EXIT,
2680 0, 0, 0,
2681 syscall_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2682 if(ret) hn--;
2683
2684 ret = lttv_trace_find_hook(ts->parent.t,
2685 LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_ENTRY,
2686 LTT_FIELD_TRAP_ID, 0, 0,
2687 trap_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2688 if(ret) hn--;
2689
2690 ret = lttv_trace_find_hook(ts->parent.t,
2691 LTT_FACILITY_KERNEL, LTT_EVENT_TRAP_EXIT,
2692 0, 0, 0,
2693 trap_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2694 if(ret) hn--;
2695
2696 ret = lttv_trace_find_hook(ts->parent.t,
2697 LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY,
2698 LTT_FIELD_IRQ_ID, 0, 0,
2699 irq_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2700 if(ret) hn--;
2701
2702 ret = lttv_trace_find_hook(ts->parent.t,
2703 LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_EXIT,
2704 0, 0, 0,
2705 irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2706 if(ret) hn--;
2707
2708 ret = lttv_trace_find_hook(ts->parent.t,
2709 LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_ENTRY,
2710 LTT_FIELD_SOFT_IRQ_ID, 0, 0,
2711 soft_irq_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2712 if(ret) hn--;
2713
2714 ret = lttv_trace_find_hook(ts->parent.t,
2715 LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_EXIT,
2716 0, 0, 0,
2717 soft_irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2718 if(ret) hn--;
2719
2720 ret = lttv_trace_find_hook(ts->parent.t,
2721 LTT_FACILITY_PROCESS, LTT_EVENT_SCHEDCHANGE,
2722 LTT_FIELD_OUT, LTT_FIELD_IN, LTT_FIELD_OUT_STATE,
2723 schedchange, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2724 if(ret) hn--;
2725
2726 ret = lttv_trace_find_hook(ts->parent.t,
2727 LTT_FACILITY_PROCESS, LTT_EVENT_FORK,
2728 LTT_FIELD_PARENT_PID, LTT_FIELD_CHILD_PID, LTT_FIELD_TGID,
2729 process_fork, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2730 if(ret) hn--;
2731
2732 ret = lttv_trace_find_hook(ts->parent.t,
2733 LTT_FACILITY_PROCESS, LTT_EVENT_KERNEL_THREAD,
2734 LTT_FIELD_PID, 0, 0,
2735 process_kernel_thread, NULL, &g_array_index(hooks, LttvTraceHook,
2736 hn++));
2737 if(ret) hn--;
2738
2739 ret = lttv_trace_find_hook(ts->parent.t,
2740 LTT_FACILITY_PROCESS, LTT_EVENT_EXIT,
2741 LTT_FIELD_PID, 0, 0,
2742 process_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2743 if(ret) hn--;
2744
2745 ret = lttv_trace_find_hook(ts->parent.t,
2746 LTT_FACILITY_PROCESS, LTT_EVENT_FREE,
2747 LTT_FIELD_PID, 0, 0,
2748 process_free, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2749 if(ret) hn--;
2750
2751 ret = lttv_trace_find_hook(ts->parent.t,
2752 LTT_FACILITY_FS, LTT_EVENT_EXEC,
2753 LTT_FIELD_FILENAME, 0, 0,
2754 process_exec, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2755 if(ret) hn--;
2756
2757 ret = lttv_trace_find_hook(ts->parent.t,
2758 LTT_FACILITY_USER_GENERIC, LTT_EVENT_THREAD_BRAND,
2759 LTT_FIELD_NAME, 0, 0,
2760 thread_brand, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2761 if(ret) hn--;
2762
2763 /* statedump-related hooks */
2764 ret = lttv_trace_find_hook(ts->parent.t,
2765 LTT_FACILITY_STATEDUMP, LTT_EVENT_ENUM_PROCESS_STATE,
2766 LTT_FIELD_PID, LTT_FIELD_PARENT_PID, LTT_FIELD_NAME,
2767 enum_process_state, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2768 if(ret) hn--;
2769
2770 ret = lttv_trace_find_hook(ts->parent.t,
2771 LTT_FACILITY_STATEDUMP, LTT_EVENT_STATEDUMP_END,
2772 0, 0, 0,
2773 statedump_end, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2774 if(ret) hn--;
2775
2776 ret = lttv_trace_find_hook(ts->parent.t,
2777 LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_ENTRY,
2778 LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE, 0,
2779 function_entry, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2780 if(ret) hn--;
2781
2782 ret = lttv_trace_find_hook(ts->parent.t,
2783 LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_EXIT,
2784 LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE, 0,
2785 function_exit, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
2786 if(ret) hn--;
2787
2788 hooks = g_array_set_size(hooks, hn);
2789
2790 /* Add these hooks to each event_by_id hooks list */
2791
2792 nb_tracefile = ts->parent.tracefiles->len;
2793
2794 for(j = 0 ; j < nb_tracefile ; j++) {
2795 tfs =
2796 LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
2797 LttvTracefileContext*, j));
2798
2799 for(k = 0 ; k < hooks->len ; k++) {
2800 hook = &g_array_index(hooks, LttvTraceHook, k);
2801 for(l=0;l<hook->fac_list->len;l++) {
2802 thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l);
2803 lttv_hooks_add(
2804 lttv_hooks_by_id_find(tfs->parent.event_by_id, thf->id),
2805 thf->h,
2806 thf,
2807 LTTV_PRIO_STATE);
2808 }
2809 }
2810 }
2811 lttv_attribute_find(ts->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
2812 *(val.v_pointer) = hooks;
2813 }
2814}
2815
2816gint lttv_state_hook_remove_event_hooks(void *hook_data, void *call_data)
2817{
2818 LttvTracesetState *tss = (LttvTracesetState*)(call_data);
2819
2820 lttv_state_remove_event_hooks(tss);
2821
2822 return 0;
2823}
2824
2825void lttv_state_remove_event_hooks(LttvTracesetState *self)
2826{
2827 LttvTraceset *traceset = self->parent.ts;
2828
2829 guint i, j, k, l, nb_trace, nb_tracefile;
2830
2831 LttvTraceState *ts;
2832
2833 LttvTracefileState *tfs;
2834
2835 GArray *hooks;
2836
2837 LttvTraceHook *hook;
2838
2839 LttvTraceHookByFacility *thf;
2840
2841 LttvAttributeValue val;
2842
2843 nb_trace = lttv_traceset_number(traceset);
2844 for(i = 0 ; i < nb_trace ; i++) {
2845 ts = LTTV_TRACE_STATE(self->parent.traces[i]);
2846
2847 lttv_attribute_find(ts->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
2848 hooks = *(val.v_pointer);
2849
2850 /* Remove these hooks from each event_by_id hooks list */
2851
2852 nb_tracefile = ts->parent.tracefiles->len;
2853
2854 for(j = 0 ; j < nb_tracefile ; j++) {
2855 tfs =
2856 LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
2857 LttvTracefileContext*, j));
2858
2859 for(k = 0 ; k < hooks->len ; k++) {
2860 hook = &g_array_index(hooks, LttvTraceHook, k);
2861 for(l=0;l<hook->fac_list->len;l++) {
2862 thf = g_array_index(hook->fac_list, LttvTraceHookByFacility*, l);
2863
2864 lttv_hooks_remove_data(
2865 lttv_hooks_by_id_find(tfs->parent.event_by_id, thf->id),
2866 thf->h,
2867 thf);
2868 }
2869 }
2870 }
2871 for(k = 0 ; k < hooks->len ; k++)
2872 lttv_trace_hook_destroy(&g_array_index(hooks, LttvTraceHook, k));
2873 g_array_free(hooks, TRUE);
2874 }
2875}
2876
2877static gboolean state_save_event_hook(void *hook_data, void *call_data)
2878{
2879 guint *event_count = (guint*)hook_data;
2880
2881 /* Only save at LTTV_STATE_SAVE_INTERVAL */
2882 if(likely((*event_count)++ < LTTV_STATE_SAVE_INTERVAL))
2883 return FALSE;
2884 else
2885 *event_count = 0;
2886
2887 LttvTracefileState *self = (LttvTracefileState *)call_data;
2888
2889 LttvTracefileState *tfcs;
2890
2891 LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
2892
2893 LttEventPosition *ep;
2894
2895 guint i;
2896
2897 LttTracefile *tf;
2898
2899 LttvAttribute *saved_states_tree, *saved_state_tree;
2900
2901 LttvAttributeValue value;
2902
2903 saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
2904 LTTV_STATE_SAVED_STATES);
2905 saved_state_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
2906 value = lttv_attribute_add(saved_states_tree,
2907 lttv_attribute_get_number(saved_states_tree), LTTV_GOBJECT);
2908 *(value.v_gobject) = (GObject *)saved_state_tree;
2909 value = lttv_attribute_add(saved_state_tree, LTTV_STATE_TIME, LTTV_TIME);
2910 *(value.v_time) = self->parent.timestamp;
2911 lttv_state_save(tcs, saved_state_tree);
2912 g_debug("Saving state at time %lu.%lu", self->parent.timestamp.tv_sec,
2913 self->parent.timestamp.tv_nsec);
2914
2915 *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
2916
2917 return FALSE;
2918}
2919
2920static gboolean state_save_after_trace_hook(void *hook_data, void *call_data)
2921{
2922 LttvTraceState *tcs = (LttvTraceState *)(call_data);
2923
2924 *(tcs->max_time_state_recomputed_in_seek) = tcs->parent.time_span.end_time;
2925
2926 return FALSE;
2927}
2928
2929guint lttv_state_current_cpu(LttvTracefileState *tfs)
2930{
2931 return tfs->cpu;
2932}
2933
2934
2935
2936#if 0
2937static gboolean block_start(void *hook_data, void *call_data)
2938{
2939 LttvTracefileState *self = (LttvTracefileState *)call_data;
2940
2941 LttvTracefileState *tfcs;
2942
2943 LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
2944
2945 LttEventPosition *ep;
2946
2947 guint i, nb_block, nb_event, nb_tracefile;
2948
2949 LttTracefile *tf;
2950
2951 LttvAttribute *saved_states_tree, *saved_state_tree;
2952
2953 LttvAttributeValue value;
2954
2955 ep = ltt_event_position_new();
2956
2957 nb_tracefile = tcs->parent.tracefiles->len;
2958
2959 /* Count the number of events added since the last block end in any
2960 tracefile. */
2961
2962 for(i = 0 ; i < nb_tracefile ; i++) {
2963 tfcs =
2964 LTTV_TRACEFILE_STATE(&g_array_index(tcs->parent.tracefiles,
2965 LttvTracefileContext, i));
2966 ltt_event_position(tfcs->parent.e, ep);
2967 ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
2968 tcs->nb_event += nb_event - tfcs->saved_position;
2969 tfcs->saved_position = nb_event;
2970 }
2971 g_free(ep);
2972
2973 if(tcs->nb_event >= tcs->save_interval) {
2974 saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
2975 LTTV_STATE_SAVED_STATES);
2976 saved_state_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
2977 value = lttv_attribute_add(saved_states_tree,
2978 lttv_attribute_get_number(saved_states_tree), LTTV_GOBJECT);
2979 *(value.v_gobject) = (GObject *)saved_state_tree;
2980 value = lttv_attribute_add(saved_state_tree, LTTV_STATE_TIME, LTTV_TIME);
2981 *(value.v_time) = self->parent.timestamp;
2982 lttv_state_save(tcs, saved_state_tree);
2983 tcs->nb_event = 0;
2984 g_debug("Saving state at time %lu.%lu", self->parent.timestamp.tv_sec,
2985 self->parent.timestamp.tv_nsec);
2986 }
2987 *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
2988 return FALSE;
2989}
2990#endif //0
2991
2992#if 0
2993static gboolean block_end(void *hook_data, void *call_data)
2994{
2995 LttvTracefileState *self = (LttvTracefileState *)call_data;
2996
2997 LttvTraceState *tcs = (LttvTraceState *)(self->parent.t_context);
2998
2999 LttTracefile *tf;
3000
3001 LttEventPosition *ep;
3002
3003 guint nb_block, nb_event;
3004
3005 ep = ltt_event_position_new();
3006 ltt_event_position(self->parent.e, ep);
3007 ltt_event_position_get(ep, &nb_block, &nb_event, &tf);
3008 tcs->nb_event += nb_event - self->saved_position + 1;
3009 self->saved_position = 0;
3010 *(tcs->max_time_state_recomputed_in_seek) = self->parent.timestamp;
3011 g_free(ep);
3012
3013 return FALSE;
3014}
3015#endif //0
3016#if 0
3017void lttv_state_save_add_event_hooks(LttvTracesetState *self)
3018{
3019 LttvTraceset *traceset = self->parent.ts;
3020
3021 guint i, j, nb_trace, nb_tracefile;
3022
3023 LttvTraceState *ts;
3024
3025 LttvTracefileState *tfs;
3026
3027 LttvTraceHook hook_start, hook_end;
3028
3029 nb_trace = lttv_traceset_number(traceset);
3030 for(i = 0 ; i < nb_trace ; i++) {
3031 ts = (LttvTraceState *)self->parent.traces[i];
3032
3033 lttv_trace_find_hook(ts->parent.t, "core","block_start",NULL,
3034 NULL, NULL, block_start, &hook_start);
3035 lttv_trace_find_hook(ts->parent.t, "core","block_end",NULL,
3036 NULL, NULL, block_end, &hook_end);
3037
3038 nb_tracefile = ts->parent.tracefiles->len;
3039
3040 for(j = 0 ; j < nb_tracefile ; j++) {
3041 tfs =
3042 LTTV_TRACEFILE_STATE(&g_array_index(ts->parent.tracefiles,
3043 LttvTracefileContext, j));
3044 lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
3045 hook_start.id), hook_start.h, NULL, LTTV_PRIO_STATE);
3046 lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.event_by_id,
3047 hook_end.id), hook_end.h, NULL, LTTV_PRIO_STATE);
3048 }
3049 }
3050}
3051#endif //0
3052
3053void lttv_state_save_add_event_hooks(LttvTracesetState *self)
3054{
3055 LttvTraceset *traceset = self->parent.ts;
3056
3057 guint i, j, nb_trace, nb_tracefile;
3058
3059 LttvTraceState *ts;
3060
3061 LttvTracefileState *tfs;
3062
3063
3064 nb_trace = lttv_traceset_number(traceset);
3065 for(i = 0 ; i < nb_trace ; i++) {
3066
3067 ts = (LttvTraceState *)self->parent.traces[i];
3068 nb_tracefile = ts->parent.tracefiles->len;
3069
3070 if(ts->has_precomputed_states) continue;
3071
3072 guint *event_count = g_new(guint, 1);
3073 *event_count = 0;
3074
3075 for(j = 0 ; j < nb_tracefile ; j++) {
3076 tfs =
3077 LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
3078 LttvTracefileContext*, j));
3079 lttv_hooks_add(tfs->parent.event,
3080 state_save_event_hook,
3081 event_count,
3082 LTTV_PRIO_STATE);
3083
3084 }
3085 }
3086
3087 lttv_process_traceset_begin(&self->parent,
3088 NULL, NULL, NULL, NULL, NULL);
3089
3090}
3091
3092gint lttv_state_save_hook_add_event_hooks(void *hook_data, void *call_data)
3093{
3094 LttvTracesetState *tss = (LttvTracesetState*)(call_data);
3095
3096 lttv_state_save_add_event_hooks(tss);
3097
3098 return 0;
3099}
3100
3101
3102#if 0
3103void lttv_state_save_remove_event_hooks(LttvTracesetState *self)
3104{
3105 LttvTraceset *traceset = self->parent.ts;
3106
3107 guint i, j, nb_trace, nb_tracefile;
3108
3109 LttvTraceState *ts;
3110
3111 LttvTracefileState *tfs;
3112
3113 LttvTraceHook hook_start, hook_end;
3114
3115 nb_trace = lttv_traceset_number(traceset);
3116 for(i = 0 ; i < nb_trace ; i++) {
3117 ts = LTTV_TRACE_STATE(self->parent.traces[i]);
3118
3119 lttv_trace_find_hook(ts->parent.t, "core","block_start",NULL,
3120 NULL, NULL, block_start, &hook_start);
3121
3122 lttv_trace_find_hook(ts->parent.t, "core","block_end",NULL,
3123 NULL, NULL, block_end, &hook_end);
3124
3125 nb_tracefile = ts->parent.tracefiles->len;
3126
3127 for(j = 0 ; j < nb_tracefile ; j++) {
3128 tfs =
3129 LTTV_TRACEFILE_STATE(&g_array_index(ts->parent.tracefiles,
3130 LttvTracefileContext, j));
3131 lttv_hooks_remove_data(lttv_hooks_by_id_find(
3132 tfs->parent.event_by_id, hook_start.id), hook_start.h, NULL);
3133 lttv_hooks_remove_data(lttv_hooks_by_id_find(
3134 tfs->parent.event_by_id, hook_end.id), hook_end.h, NULL);
3135 }
3136 }
3137}
3138#endif //0
3139
3140void lttv_state_save_remove_event_hooks(LttvTracesetState *self)
3141{
3142 LttvTraceset *traceset = self->parent.ts;
3143
3144 guint i, j, nb_trace, nb_tracefile;
3145
3146 LttvTraceState *ts;
3147
3148 LttvTracefileState *tfs;
3149
3150 LttvHooks *after_trace = lttv_hooks_new();
3151
3152 lttv_hooks_add(after_trace,
3153 state_save_after_trace_hook,
3154 NULL,
3155 LTTV_PRIO_STATE);
3156
3157
3158 lttv_process_traceset_end(&self->parent,
3159 NULL, after_trace, NULL, NULL, NULL);
3160
3161 lttv_hooks_destroy(after_trace);
3162
3163 nb_trace = lttv_traceset_number(traceset);
3164 for(i = 0 ; i < nb_trace ; i++) {
3165
3166 ts = (LttvTraceState *)self->parent.traces[i];
3167 nb_tracefile = ts->parent.tracefiles->len;
3168
3169 if(ts->has_precomputed_states) continue;
3170
3171 guint *event_count = NULL;
3172
3173 for(j = 0 ; j < nb_tracefile ; j++) {
3174 tfs =
3175 LTTV_TRACEFILE_STATE(g_array_index(ts->parent.tracefiles,
3176 LttvTracefileContext*, j));
3177 event_count = lttv_hooks_remove(tfs->parent.event,
3178 state_save_event_hook);
3179 }
3180 if(event_count) g_free(event_count);
3181 }
3182}
3183
3184gint lttv_state_save_hook_remove_event_hooks(void *hook_data, void *call_data)
3185{
3186 LttvTracesetState *tss = (LttvTracesetState*)(call_data);
3187
3188 lttv_state_save_remove_event_hooks(tss);
3189
3190 return 0;
3191}
3192
3193void lttv_state_traceset_seek_time_closest(LttvTracesetState *self, LttTime t)
3194{
3195 LttvTraceset *traceset = self->parent.ts;
3196
3197 guint i, nb_trace;
3198
3199 int min_pos, mid_pos, max_pos;
3200
3201 guint call_rest = 0;
3202
3203 LttvTraceState *tcs;
3204
3205 LttvAttributeValue value;
3206
3207 LttvAttributeType type;
3208
3209 LttvAttributeName name;
3210
3211 gboolean is_named;
3212
3213 LttvAttribute *saved_states_tree, *saved_state_tree, *closest_tree;
3214
3215 //g_tree_destroy(self->parent.pqueue);
3216 //self->parent.pqueue = g_tree_new(compare_tracefile);
3217
3218 g_info("Entering seek_time_closest for time %lu.%lu", t.tv_sec, t.tv_nsec);
3219
3220 nb_trace = lttv_traceset_number(traceset);
3221 for(i = 0 ; i < nb_trace ; i++) {
3222 tcs = (LttvTraceState *)self->parent.traces[i];
3223
3224 if(ltt_time_compare(t, *(tcs->max_time_state_recomputed_in_seek)) < 0) {
3225 saved_states_tree = lttv_attribute_find_subdir(tcs->parent.t_a,
3226 LTTV_STATE_SAVED_STATES);
3227 min_pos = -1;
3228
3229 if(saved_states_tree) {
3230 max_pos = lttv_attribute_get_number(saved_states_tree) - 1;
3231 mid_pos = max_pos / 2;
3232 while(min_pos < max_pos) {
3233 type = lttv_attribute_get(saved_states_tree, mid_pos, &name, &value,
3234 &is_named);
3235 g_assert(type == LTTV_GOBJECT);
3236 saved_state_tree = *((LttvAttribute **)(value.v_gobject));
3237 type = lttv_attribute_get_by_name(saved_state_tree, LTTV_STATE_TIME,
3238 &value);
3239 g_assert(type == LTTV_TIME);
3240 if(ltt_time_compare(*(value.v_time), t) < 0) {
3241 min_pos = mid_pos;
3242 closest_tree = saved_state_tree;
3243 }
3244 else max_pos = mid_pos - 1;
3245
3246 mid_pos = (min_pos + max_pos + 1) / 2;
3247 }
3248 }
3249
3250 /* restore the closest earlier saved state */
3251 if(min_pos != -1) {
3252 lttv_state_restore(tcs, closest_tree);
3253 call_rest = 1;
3254 }
3255
3256 /* There is no saved state, yet we want to have it. Restart at T0 */
3257 else {
3258 restore_init_state(tcs);
3259 lttv_process_trace_seek_time(&(tcs->parent), ltt_time_zero);
3260 }
3261 }
3262 /* We want to seek quickly without restoring/updating the state */
3263 else {
3264 restore_init_state(tcs);
3265 lttv_process_trace_seek_time(&(tcs->parent), t);
3266 }
3267 }
3268 if(!call_rest) g_info("NOT Calling restore");
3269}
3270
3271
3272static void
3273traceset_state_instance_init (GTypeInstance *instance, gpointer g_class)
3274{
3275}
3276
3277
3278static void
3279traceset_state_finalize (LttvTracesetState *self)
3280{
3281 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACESET_CONTEXT_TYPE))->
3282 finalize(G_OBJECT(self));
3283}
3284
3285
3286static void
3287traceset_state_class_init (LttvTracesetContextClass *klass)
3288{
3289 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
3290
3291 gobject_class->finalize = (void (*)(GObject *self)) traceset_state_finalize;
3292 klass->init = (void (*)(LttvTracesetContext *self, LttvTraceset *ts))init;
3293 klass->fini = (void (*)(LttvTracesetContext *self))fini;
3294 klass->new_traceset_context = new_traceset_context;
3295 klass->new_trace_context = new_trace_context;
3296 klass->new_tracefile_context = new_tracefile_context;
3297}
3298
3299
3300GType
3301lttv_traceset_state_get_type(void)
3302{
3303 static GType type = 0;
3304 if (type == 0) {
3305 static const GTypeInfo info = {
3306 sizeof (LttvTracesetStateClass),
3307 NULL, /* base_init */
3308 NULL, /* base_finalize */
3309 (GClassInitFunc) traceset_state_class_init, /* class_init */
3310 NULL, /* class_finalize */
3311 NULL, /* class_data */
3312 sizeof (LttvTracesetState),
3313 0, /* n_preallocs */
3314 (GInstanceInitFunc) traceset_state_instance_init, /* instance_init */
3315 NULL /* value handling */
3316 };
3317
3318 type = g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE, "LttvTracesetStateType",
3319 &info, 0);
3320 }
3321 return type;
3322}
3323
3324
3325static void
3326trace_state_instance_init (GTypeInstance *instance, gpointer g_class)
3327{
3328}
3329
3330
3331static void
3332trace_state_finalize (LttvTraceState *self)
3333{
3334 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACE_CONTEXT_TYPE))->
3335 finalize(G_OBJECT(self));
3336}
3337
3338
3339static void
3340trace_state_class_init (LttvTraceStateClass *klass)
3341{
3342 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
3343
3344 gobject_class->finalize = (void (*)(GObject *self)) trace_state_finalize;
3345 klass->state_save = state_save;
3346 klass->state_restore = state_restore;
3347 klass->state_saved_free = state_saved_free;
3348}
3349
3350
3351GType
3352lttv_trace_state_get_type(void)
3353{
3354 static GType type = 0;
3355 if (type == 0) {
3356 static const GTypeInfo info = {
3357 sizeof (LttvTraceStateClass),
3358 NULL, /* base_init */
3359 NULL, /* base_finalize */
3360 (GClassInitFunc) trace_state_class_init, /* class_init */
3361 NULL, /* class_finalize */
3362 NULL, /* class_data */
3363 sizeof (LttvTraceState),
3364 0, /* n_preallocs */
3365 (GInstanceInitFunc) trace_state_instance_init, /* instance_init */
3366 NULL /* value handling */
3367 };
3368
3369 type = g_type_register_static (LTTV_TRACE_CONTEXT_TYPE,
3370 "LttvTraceStateType", &info, 0);
3371 }
3372 return type;
3373}
3374
3375
3376static void
3377tracefile_state_instance_init (GTypeInstance *instance, gpointer g_class)
3378{
3379}
3380
3381
3382static void
3383tracefile_state_finalize (LttvTracefileState *self)
3384{
3385 G_OBJECT_CLASS(g_type_class_peek(LTTV_TRACEFILE_CONTEXT_TYPE))->
3386 finalize(G_OBJECT(self));
3387}
3388
3389
3390static void
3391tracefile_state_class_init (LttvTracefileStateClass *klass)
3392{
3393 GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
3394
3395 gobject_class->finalize = (void (*)(GObject *self)) tracefile_state_finalize;
3396}
3397
3398
3399GType
3400lttv_tracefile_state_get_type(void)
3401{
3402 static GType type = 0;
3403 if (type == 0) {
3404 static const GTypeInfo info = {
3405 sizeof (LttvTracefileStateClass),
3406 NULL, /* base_init */
3407 NULL, /* base_finalize */
3408 (GClassInitFunc) tracefile_state_class_init, /* class_init */
3409 NULL, /* class_finalize */
3410 NULL, /* class_data */
3411 sizeof (LttvTracefileState),
3412 0, /* n_preallocs */
3413 (GInstanceInitFunc) tracefile_state_instance_init, /* instance_init */
3414 NULL /* value handling */
3415 };
3416
3417 type = g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE,
3418 "LttvTracefileStateType", &info, 0);
3419 }
3420 return type;
3421}
3422
3423
3424static void module_init()
3425{
3426 LTTV_STATE_UNNAMED = g_quark_from_string("UNNAMED");
3427 LTTV_STATE_UNBRANDED = g_quark_from_string("UNBRANDED");
3428 LTTV_STATE_MODE_UNKNOWN = g_quark_from_string("MODE_UNKNOWN");
3429 LTTV_STATE_USER_MODE = g_quark_from_string("USER_MODE");
3430 LTTV_STATE_SYSCALL = g_quark_from_string("SYSCALL");
3431 LTTV_STATE_TRAP = g_quark_from_string("TRAP");
3432 LTTV_STATE_IRQ = g_quark_from_string("IRQ");
3433 LTTV_STATE_SOFT_IRQ = g_quark_from_string("SOFTIRQ");
3434 LTTV_STATE_SUBMODE_UNKNOWN = g_quark_from_string("UNKNOWN");
3435 LTTV_STATE_SUBMODE_NONE = g_quark_from_string("NONE");
3436 LTTV_STATE_WAIT_FORK = g_quark_from_string("WAIT_FORK");
3437 LTTV_STATE_WAIT_CPU = g_quark_from_string("WAIT_CPU");
3438 LTTV_STATE_EXIT = g_quark_from_string("EXIT");
3439 LTTV_STATE_ZOMBIE = g_quark_from_string("ZOMBIE");
3440 LTTV_STATE_WAIT = g_quark_from_string("WAIT");
3441 LTTV_STATE_RUN = g_quark_from_string("RUN");
3442 LTTV_STATE_DEAD = g_quark_from_string("DEAD");
3443 LTTV_STATE_USER_THREAD = g_quark_from_string("USER_THREAD");
3444 LTTV_STATE_KERNEL_THREAD = g_quark_from_string("KERNEL_THREAD");
3445 LTTV_STATE_TRACEFILES = g_quark_from_string("tracefiles");
3446 LTTV_STATE_PROCESSES = g_quark_from_string("processes");
3447 LTTV_STATE_PROCESS = g_quark_from_string("process");
3448 LTTV_STATE_RUNNING_PROCESS = g_quark_from_string("running_process");
3449 LTTV_STATE_EVENT = g_quark_from_string("event");
3450 LTTV_STATE_SAVED_STATES = g_quark_from_string("saved states");
3451 LTTV_STATE_SAVED_STATES_TIME = g_quark_from_string("saved states time");
3452 LTTV_STATE_TIME = g_quark_from_string("time");
3453 LTTV_STATE_HOOKS = g_quark_from_string("saved state hooks");
3454 LTTV_STATE_NAME_TABLES = g_quark_from_string("name tables");
3455 LTTV_STATE_TRACE_STATE_USE_COUNT =
3456 g_quark_from_string("trace_state_use_count");
3457
3458
3459 LTT_FACILITY_KERNEL = g_quark_from_string("kernel");
3460 LTT_FACILITY_KERNEL_ARCH = g_quark_from_string("kernel_arch");
3461 LTT_FACILITY_PROCESS = g_quark_from_string("process");
3462 LTT_FACILITY_FS = g_quark_from_string("fs");
3463 LTT_FACILITY_STATEDUMP = g_quark_from_string("statedump");
3464 LTT_FACILITY_USER_GENERIC = g_quark_from_string("user_generic");
3465
3466
3467 LTT_EVENT_SYSCALL_ENTRY = g_quark_from_string("syscall_entry");
3468 LTT_EVENT_SYSCALL_EXIT = g_quark_from_string("syscall_exit");
3469 LTT_EVENT_TRAP_ENTRY = g_quark_from_string("trap_entry");
3470 LTT_EVENT_TRAP_EXIT = g_quark_from_string("trap_exit");
3471 LTT_EVENT_IRQ_ENTRY = g_quark_from_string("irq_entry");
3472 LTT_EVENT_IRQ_EXIT = g_quark_from_string("irq_exit");
3473 LTT_EVENT_SOFT_IRQ_ENTRY = g_quark_from_string("soft_irq_entry");
3474 LTT_EVENT_SOFT_IRQ_EXIT = g_quark_from_string("soft_irq_exit");
3475 LTT_EVENT_SCHEDCHANGE = g_quark_from_string("schedchange");
3476 LTT_EVENT_FORK = g_quark_from_string("fork");
3477 LTT_EVENT_KERNEL_THREAD = g_quark_from_string("kernel_thread");
3478 LTT_EVENT_EXIT = g_quark_from_string("exit");
3479 LTT_EVENT_FREE = g_quark_from_string("free");
3480 LTT_EVENT_EXEC = g_quark_from_string("exec");
3481 LTT_EVENT_ENUM_PROCESS_STATE = g_quark_from_string("enumerate_process_state");
3482 LTT_EVENT_STATEDUMP_END = g_quark_from_string("statedump_end");
3483 LTT_EVENT_FUNCTION_ENTRY = g_quark_from_string("function_entry");
3484 LTT_EVENT_FUNCTION_EXIT = g_quark_from_string("function_exit");
3485 LTT_EVENT_THREAD_BRAND = g_quark_from_string("thread_brand");
3486
3487
3488 LTT_FIELD_SYSCALL_ID = g_quark_from_string("syscall_id");
3489 LTT_FIELD_TRAP_ID = g_quark_from_string("trap_id");
3490 LTT_FIELD_IRQ_ID = g_quark_from_string("irq_id");
3491 LTT_FIELD_SOFT_IRQ_ID = g_quark_from_string("softirq_id");
3492 LTT_FIELD_OUT = g_quark_from_string("out");
3493 LTT_FIELD_IN = g_quark_from_string("in");
3494 LTT_FIELD_OUT_STATE = g_quark_from_string("out_state");
3495 LTT_FIELD_PARENT_PID = g_quark_from_string("parent_pid");
3496 LTT_FIELD_CHILD_PID = g_quark_from_string("child_pid");
3497 LTT_FIELD_PID = g_quark_from_string("pid");
3498 LTT_FIELD_TGID = g_quark_from_string("tgid");
3499 LTT_FIELD_FILENAME = g_quark_from_string("filename");
3500 LTT_FIELD_NAME = g_quark_from_string("name");
3501 LTT_FIELD_TYPE = g_quark_from_string("type");
3502 LTT_FIELD_MODE = g_quark_from_string("mode");
3503 LTT_FIELD_SUBMODE = g_quark_from_string("submode");
3504 LTT_FIELD_STATUS = g_quark_from_string("status");
3505 LTT_FIELD_THIS_FN = g_quark_from_string("this_fn");
3506 LTT_FIELD_CALL_SITE = g_quark_from_string("call_site");
3507
3508}
3509
3510static void module_destroy()
3511{
3512}
3513
3514
3515LTTV_MODULE("state", "State computation", \
3516 "Update the system state, possibly saving it at intervals", \
3517 module_init, module_destroy)
3518
3519
3520
LTTng 2.x Viewer (LTTV)
This page took 0.034117 seconds and 4 git commands to generate.