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