+ saved_states_tree = lttv_attribute_find_subdir(self->parent.t_a,
+ LTTV_STATE_SAVED_STATES);
+ saved_state_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
+ value = lttv_attribute_add(saved_states_tree,
+ lttv_attribute_get_number(saved_states_tree), LTTV_GOBJECT);
+ *(value.v_gobject) = (GObject *)saved_state_tree;
+ value = lttv_attribute_add(saved_state_tree, LTTV_STATE_TIME, LTTV_TIME);
+ *(value.v_time) = t;
+ lttv_state_save(self, saved_state_tree);
+ g_debug("Saving state at time %lu.%lu", t.tv_sec,
+ t.tv_nsec);
+
+ *(self->max_time_state_recomputed_in_seek) = t;
+
+}
+
+/* Called when a HDR_TRACE is found */
+void lttv_trace_states_read_raw(LttvTraceState *tcs, FILE *fp,
+ GPtrArray *quarktable)
+{
+ int hdr;
+
+ do {
+ if(feof(fp) || ferror(fp)) goto end_loop;
+ hdr = fgetc(fp);
+ if(hdr == EOF) goto end_loop;
+
+ switch(hdr) {
+ case HDR_PROCESS_STATE:
+ /* Call read_process_state_raw */
+ lttv_state_read_raw(tcs, fp, quarktable);
+ break;
+ case HDR_TRACEFILE:
+ case HDR_TRACESET:
+ case HDR_TRACE:
+ case HDR_QUARKS:
+ case HDR_QUARK:
+ case HDR_ES:
+ case HDR_USER_STACK:
+ case HDR_USERTRACE:
+ case HDR_PROCESS:
+ case HDR_CPU:
+ g_error("Error while parsing saved state file :"
+ " unexpected data header %d",
+ hdr);
+ break;
+ default:
+ g_error("Error while parsing saved state file : unknown data header %d",
+ hdr);
+ };
+ } while(1);
+end_loop:
+ *(tcs->max_time_state_recomputed_in_seek) = tcs->parent.time_span.end_time;
+ restore_init_state(tcs);
+ lttv_process_trace_seek_time(&tcs->parent, ltt_time_zero);
+ return;
+}
+
+
+
+/* Copy each process from an existing hash table to a new one */
+
+static void copy_process_state(gpointer key, gpointer value,gpointer user_data)
+{
+ LttvProcessState *process, *new_process;
+
+ GHashTable *new_processes = (GHashTable *)user_data;
+
+ guint i;
+
+ process = (LttvProcessState *)value;
+ new_process = g_new(LttvProcessState, 1);
+ *new_process = *process;
+ new_process->execution_stack = g_array_sized_new(FALSE, FALSE,
+ sizeof(LttvExecutionState), PREALLOCATED_EXECUTION_STACK);
+ new_process->execution_stack =
+ g_array_set_size(new_process->execution_stack,
+ process->execution_stack->len);
+ for(i = 0 ; i < process->execution_stack->len; i++) {
+ g_array_index(new_process->execution_stack, LttvExecutionState, i) =
+ g_array_index(process->execution_stack, LttvExecutionState, i);
+ }
+ new_process->state = &g_array_index(new_process->execution_stack,
+ LttvExecutionState, new_process->execution_stack->len - 1);
+ new_process->user_stack = g_array_sized_new(FALSE, FALSE,
+ sizeof(guint64), 0);
+ new_process->user_stack =
+ g_array_set_size(new_process->user_stack,
+ process->user_stack->len);
+ for(i = 0 ; i < process->user_stack->len; i++) {
+ g_array_index(new_process->user_stack, guint64, i) =
+ g_array_index(process->user_stack, guint64, i);
+ }
+ new_process->current_function = process->current_function;
+ g_hash_table_insert(new_processes, new_process, new_process);
+}
+
+
+static GHashTable *lttv_state_copy_process_table(GHashTable *processes)
+{
+ GHashTable *new_processes = g_hash_table_new(process_hash, process_equal);
+
+ g_hash_table_foreach(processes, copy_process_state, new_processes);
+ return new_processes;
+}
+
+static LttvCPUState *lttv_state_copy_cpu_states(LttvCPUState *states, guint n)
+{
+ guint i,j;
+ LttvCPUState *retval;
+
+ retval = g_malloc(n*sizeof(LttvCPUState));
+
+ for(i=0; i<n; i++) {
+ retval[i].mode_stack = g_array_new(FALSE, FALSE, sizeof(LttvCPUMode));
+ retval[i].last_irq = states[i].last_irq;
+ g_array_set_size(retval[i].mode_stack, states[i].mode_stack->len);
+ for(j=0; j<states[i].mode_stack->len; j++) {
+ g_array_index(retval[i].mode_stack, GQuark, j) = g_array_index(states[i].mode_stack, GQuark, j);
+ }
+ }
+
+ return retval;
+}
+
+static void lttv_state_free_cpu_states(LttvCPUState *states, guint n)
+{
+ guint i;
+
+ for(i=0; i<n; i++) {
+ g_array_free(states[i].mode_stack, TRUE);
+ }
+
+ g_free(states);
+}
+
+static LttvIRQState *lttv_state_copy_irq_states(LttvIRQState *states, guint n)
+{
+ guint i,j;
+ LttvIRQState *retval;
+
+ retval = g_malloc(n*sizeof(LttvIRQState));
+
+ for(i=0; i<n; i++) {
+ retval[i].mode_stack = g_array_new(FALSE, FALSE, sizeof(LttvIRQMode));
+ g_array_set_size(retval[i].mode_stack, states[i].mode_stack->len);
+ for(j=0; j<states[i].mode_stack->len; j++) {
+ g_array_index(retval[i].mode_stack, GQuark, j) = g_array_index(states[i].mode_stack, GQuark, j);
+ }
+ }
+
+ return retval;
+}
+
+static void lttv_state_free_irq_states(LttvIRQState *states, guint n)
+{
+ guint i;
+
+ for(i=0; i<n; i++) {
+ g_array_free(states[i].mode_stack, TRUE);
+ }
+
+ g_free(states);
+}
+
+static LttvSoftIRQState *lttv_state_copy_soft_irq_states(LttvSoftIRQState *states, guint n)
+{
+ guint i,j;
+ LttvSoftIRQState *retval;
+
+ retval = g_malloc(n*sizeof(LttvSoftIRQState));
+
+ for(i=0; i<n; i++) {
+ retval[i].running = states[i].running;
+ }
+
+ return retval;
+}
+
+static void lttv_state_free_soft_irq_states(LttvIRQState *states, guint n)
+{
+ g_free(states);
+}
+
+/* bdevstate stuff */
+
+static LttvBdevState *get_hashed_bdevstate(LttvTraceState *ts, guint16 devcode)
+{
+ gint devcode_gint = devcode;
+ gpointer bdev = g_hash_table_lookup(ts->bdev_states, &devcode_gint);
+ if(bdev == NULL) {
+ LttvBdevState *bdevstate = g_malloc(sizeof(LttvBdevState));
+ bdevstate->mode_stack = g_array_new(FALSE, FALSE, sizeof(GQuark));
+
+ gint * key = g_malloc(sizeof(gint));
+ *key = devcode;
+ g_hash_table_insert(ts->bdev_states, key, bdevstate);
+
+ bdev = bdevstate;
+ }
+
+ return bdev;
+}
+
+static LttvBdevState *bdevstate_new(void)
+{
+ LttvBdevState *retval;
+ retval = g_malloc(sizeof(LttvBdevState));
+ retval->mode_stack = g_array_new(FALSE, FALSE, sizeof(GQuark));
+
+ return retval;
+}
+
+static void bdevstate_free(LttvBdevState *bds)
+{
+ g_array_free(bds->mode_stack, TRUE);
+ g_free(bds);
+}
+
+static void bdevstate_free_cb(gpointer key, gpointer value, gpointer user_data)
+{
+ LttvBdevState *bds = (LttvBdevState *) value;
+
+ bdevstate_free(bds);
+}
+
+static LttvBdevState *bdevstate_copy(LttvBdevState *bds)
+{
+ LttvBdevState *retval;
+
+ retval = bdevstate_new();
+ g_array_insert_vals(retval->mode_stack, 0, bds->mode_stack->data, bds->mode_stack->len);
+
+ return retval;
+}
+
+static void insert_and_copy_bdev_state(gpointer k, gpointer v, gpointer u)
+{
+ //GHashTable *ht = (GHashTable *)u;
+ LttvBdevState *bds = (LttvBdevState *)v;
+ LttvBdevState *newbds;
+
+ newbds = bdevstate_copy(bds);
+
+ g_hash_table_insert(u, k, newbds);
+}
+
+static GHashTable *lttv_state_copy_blkdev_hashtable(GHashTable *ht)
+{
+ GHashTable *retval;
+
+ retval = g_hash_table_new(g_int_hash, g_int_equal);
+
+ g_hash_table_foreach(ht, insert_and_copy_bdev_state, retval);
+
+ return retval;
+}
+
+/* Free a hashtable and the LttvBdevState structures its values
+ * point to. */
+
+static void lttv_state_free_blkdev_hashtable(GHashTable *ht)
+{
+ g_hash_table_foreach(ht, bdevstate_free_cb, NULL);
+ g_hash_table_destroy(ht);
+}
+
+/* The saved state for each trace contains a member "processes", which
+ stores a copy of the process table, and a member "tracefiles" with
+ one entry per tracefile. Each tracefile has a "process" member pointing
+ to the current process and a "position" member storing the tracefile
+ position (needed to seek to the current "next" event. */
+
+static void state_save(LttvTraceState *self, LttvAttribute *container)
+{
+ guint i, nb_tracefile, nb_cpus, nb_irqs;
+
+ LttvTracefileState *tfcs;
+
+ LttvAttribute *tracefiles_tree, *tracefile_tree;
+
+ guint *running_process;
+
+ LttvAttributeValue value;
+
+ LttEventPosition *ep;
+
+ tracefiles_tree = lttv_attribute_find_subdir(container,
+ LTTV_STATE_TRACEFILES);
+
+ value = lttv_attribute_add(container, LTTV_STATE_PROCESSES,
+ LTTV_POINTER);
+ *(value.v_pointer) = lttv_state_copy_process_table(self->processes);
+
+ /* Add the currently running processes array */
+ nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
+ running_process = g_new(guint, nb_cpus);
+ for(i=0;i<nb_cpus;i++) {
+ running_process[i] = self->running_process[i]->pid;
+ }
+ value = lttv_attribute_add(container, LTTV_STATE_RUNNING_PROCESS,
+ LTTV_POINTER);
+ *(value.v_pointer) = running_process;
+
+ g_info("State save");
+
+ nb_tracefile = self->parent.tracefiles->len;
+
+ for(i = 0 ; i < nb_tracefile ; i++) {
+ tfcs =
+ LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
+ LttvTracefileContext*, i));
+ tracefile_tree = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
+ value = lttv_attribute_add(tracefiles_tree, i,
+ LTTV_GOBJECT);
+ *(value.v_gobject) = (GObject *)tracefile_tree;
+#if 0
+ value = lttv_attribute_add(tracefile_tree, LTTV_STATE_PROCESS,
+ LTTV_UINT);
+ *(value.v_uint) = tfcs->process->pid;
+#endif //0
+ value = lttv_attribute_add(tracefile_tree, LTTV_STATE_EVENT,
+ LTTV_POINTER);
+ /* Only save the position if the tfs has not infinite time. */
+ //if(!g_tree_lookup(self->parent.ts_context->pqueue, &tfcs->parent)
+ // && current_tfcs != tfcs) {
+ if(ltt_time_compare(tfcs->parent.timestamp, ltt_time_infinite) == 0) {
+ *(value.v_pointer) = NULL;
+ } else {
+ LttEvent *e = ltt_tracefile_get_event(tfcs->parent.tf);
+ ep = ltt_event_position_new();
+ ltt_event_position(e, ep);
+ *(value.v_pointer) = ep;
+
+ guint nb_block, offset;
+ guint64 tsc;
+ LttTracefile *tf;
+ ltt_event_position_get(ep, &tf, &nb_block, &offset, &tsc);
+ g_info("Block %u offset %u tsc %llu time %lu.%lu", nb_block, offset,
+ tsc,
+ tfcs->parent.timestamp.tv_sec, tfcs->parent.timestamp.tv_nsec);
+ }
+ }
+
+ /* save the cpu state */
+ {
+ value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_CPUS_COUNT,
+ LTTV_UINT);
+ *(value.v_uint) = nb_cpus;
+
+ value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_CPUS,
+ LTTV_POINTER);
+ *(value.v_pointer) = lttv_state_copy_cpu_states(self->cpu_states, nb_cpus);
+ }
+
+ /* save the irq state */
+ nb_irqs = self->nb_irqs;
+ {
+ value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_IRQS,
+ LTTV_POINTER);
+ *(value.v_pointer) = lttv_state_copy_irq_states(self->irq_states, nb_irqs);
+ }
+
+ /* save the soft irq state */
+ nb_irqs = self->nb_irqs;
+ {
+ value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_SOFT_IRQS,
+ LTTV_POINTER);
+ *(value.v_pointer) = lttv_state_copy_soft_irq_states(self->soft_irq_states, nb_irqs);
+ }
+
+ /* save the blkdev states */
+ value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_BLKDEVS,
+ LTTV_POINTER);
+ *(value.v_pointer) = lttv_state_copy_blkdev_hashtable(self->bdev_states);
+}
+
+
+static void state_restore(LttvTraceState *self, LttvAttribute *container)
+{
+ guint i, nb_tracefile, pid, nb_cpus, nb_irqs, nb_soft_irqs;