+/* Read process state from a file */
+
+/* Called because a HDR_PROCESS was found */
+static void read_process_state_raw(LttvTraceState *self, FILE *fp,
+ GPtrArray *quarktable)
+{
+ LttvExecutionState *es;
+ LttvProcessState *process, *parent_process;
+ LttvProcessState tmp;
+ GQuark tmpq;
+
+ guint i;
+ guint64 *address;
+ guint cpu;
+
+ /* TODO : check return value */
+ fread(&tmp.type, sizeof(tmp.type), 1, fp);
+ fread(&tmp.name, sizeof(tmp.name), 1, fp);
+ fread(&tmp.brand, sizeof(tmp.brand), 1, fp);
+ fread(&tmp.pid, sizeof(tmp.pid), 1, fp);
+ fread(&tmp.tgid, sizeof(tmp.tgid), 1, fp);
+ fread(&tmp.ppid, sizeof(tmp.ppid), 1, fp);
+ fread(&tmp.cpu, sizeof(tmp.cpu), 1, fp);
+ fread(&tmp.creation_time, sizeof(tmp.creation_time), 1, fp);
+ fread(&tmp.insertion_time, sizeof(tmp.insertion_time), 1, fp);
+
+ if(tmp.pid == 0) {
+ process = lttv_state_find_process(self, tmp.cpu, tmp.pid);
+ } else {
+ /* We must link to the parent */
+ parent_process = lttv_state_find_process_or_create(self, ANY_CPU, tmp.ppid,
+ <t_time_zero);
+ process = lttv_state_find_process_or_create(self, tmp.cpu, tmp.pid,
+ &tmp.creation_time);
+ }
+ process->insertion_time = tmp.insertion_time;
+ process->creation_time = tmp.creation_time;
+ process->type = g_quark_from_string(
+ (gchar*)g_ptr_array_index(quarktable, tmp.type));
+ process->tgid = tmp.tgid;
+ process->ppid = tmp.ppid;
+ process->brand = g_quark_from_string(
+ (gchar*)g_ptr_array_index(quarktable, tmp.brand));
+ process->name =
+ g_quark_from_string((gchar*)g_ptr_array_index(quarktable, tmp.name));
+
+ do {
+ if(feof(fp) || ferror(fp)) goto end_loop;
+
+ gint hdr = fgetc(fp);
+ if(hdr == EOF) goto end_loop;
+
+ switch(hdr) {
+ case HDR_ES:
+ process->execution_stack =
+ g_array_set_size(process->execution_stack,
+ process->execution_stack->len + 1);
+ es = &g_array_index(process->execution_stack, LttvExecutionState,
+ process->execution_stack->len-1);
+
+ fread(&es->t, sizeof(es->t), 1, fp);
+ es->t = g_quark_from_string(
+ (gchar*)g_ptr_array_index(quarktable, es->t));
+ fread(&es->n, sizeof(es->n), 1, fp);
+ es->n = g_quark_from_string(
+ (gchar*)g_ptr_array_index(quarktable, es->n));
+ fread(&es->s, sizeof(es->s), 1, fp);
+ es->s = g_quark_from_string(
+ (gchar*)g_ptr_array_index(quarktable, es->s));
+ fread(&es->entry, sizeof(es->entry), 1, fp);
+ fread(&es->change, sizeof(es->change), 1, fp);
+ fread(&es->cum_cpu_time, sizeof(es->cum_cpu_time), 1, fp);
+ break;
+ case HDR_USER_STACK:
+ process->user_stack = g_array_set_size(process->user_stack,
+ process->user_stack->len + 1);
+ address = &g_array_index(process->user_stack, guint64,
+ process->user_stack->len-1);
+ fread(address, sizeof(address), 1, fp);
+ process->current_function = *address;
+ break;
+ case HDR_USERTRACE:
+ fread(&tmpq, sizeof(tmpq), 1, fp);
+ fread(&process->usertrace->cpu, sizeof(process->usertrace->cpu), 1, fp);
+ break;
+ default:
+ ungetc(hdr, fp);
+ goto end_loop;
+ };
+ } while(1);
+end_loop:
+ return;
+}
+
+
+/* Called because a HDR_PROCESS_STATE was found */
+/* Append a saved state to the trace states */
+void lttv_state_read_raw(LttvTraceState *self, FILE *fp, GPtrArray *quarktable)
+{
+ guint i, nb_tracefile, nb_block, offset;
+ guint64 tsc;
+ LttvTracefileState *tfcs;
+
+ LttEventPosition *ep;
+
+ guint nb_cpus;
+
+ int hdr;
+
+ LttTime t;
+
+ LttvAttribute *saved_states_tree, *saved_state_tree;
+
+ LttvAttributeValue value;
+ ep = ltt_event_position_new();
+
+ restore_init_state(self);
+
+ fread(&t, sizeof(t), 1, fp);
+
+ do {
+ if(feof(fp) || ferror(fp)) goto end_loop;
+ hdr = fgetc(fp);
+ if(hdr == EOF) goto end_loop;
+
+ switch(hdr) {
+ case HDR_PROCESS:
+ /* Call read_process_state_raw */
+ read_process_state_raw(self, 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_STATE:
+ case HDR_CPU:
+ ungetc(hdr, fp);
+ goto end_loop;
+ break;
+ default:
+ g_error("Error while parsing saved state file : unknown data header %d",
+ hdr);
+ };
+ } while(1);
+end_loop:
+
+ nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
+ for(i=0;i<nb_cpus;i++) {
+ int cpu_num;
+ hdr = fgetc(fp);
+ g_assert(hdr == HDR_CPU);
+ fread(&cpu_num, sizeof(cpu_num), 1, fp); /* cpu number */
+ g_assert(i == cpu_num);
+ fread(&self->running_process[i]->pid,
+ sizeof(self->running_process[i]->pid), 1, fp);
+ }
+
+ 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));
+ // fprintf(fp, " <TRACEFILE TIMESTAMP_S=%lu TIMESTAMP_NS=%lu",
+ // tfcs->parent.timestamp.tv_sec,
+ // tfcs->parent.timestamp.tv_nsec);
+ hdr = fgetc(fp);
+ g_assert(hdr == HDR_TRACEFILE);
+ fread(&tfcs->parent.timestamp, sizeof(tfcs->parent.timestamp), 1, fp);
+ /* Note : if timestamp if LTT_TIME_INFINITE, there will be no
+ * position following : end of trace */
+ if(ltt_time_compare(tfcs->parent.timestamp, ltt_time_infinite) != 0) {
+ fread(&nb_block, sizeof(nb_block), 1, fp);
+ fread(&offset, sizeof(offset), 1, fp);
+ fread(&tsc, sizeof(tsc), 1, fp);
+ ltt_event_position_set(ep, tfcs->parent.tf, nb_block, offset, tsc);
+ gint ret = ltt_tracefile_seek_position(tfcs->parent.tf, ep);
+ g_assert(ret == 0);
+ }
+ }
+ g_free(ep);
+
+ 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;
+}
+
+
+