* MA 02111-1307, USA.
*/
+#define _GNU_SOURCE
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <lttv/lttv.h>
#include <lttv/module.h>
#include <lttv/state.h>
-#include <ltt/facility.h>
#include <ltt/trace.h>
#include <ltt/event.h>
-#include <ltt/type.h>
+#include <ltt/ltt.h>
#include <stdio.h>
#include <string.h>
LTT_EVENT_FUNCTION_EXIT,
LTT_EVENT_THREAD_BRAND,
LTT_EVENT_REQUEST_ISSUE,
- LTT_EVENT_REQUEST_COMPLETE;
+ LTT_EVENT_REQUEST_COMPLETE,
+ LTT_EVENT_LIST_INTERRUPT;
/* Fields Quarks */
LTT_FIELD_CALL_SITE,
LTT_FIELD_MINOR,
LTT_FIELD_MAJOR,
- LTT_FIELD_OPERATION;
+ LTT_FIELD_OPERATION,
+ LTT_FIELD_ACTION,
+ LTT_FIELD_NUM;
LttvExecutionMode
LTTV_STATE_MODE_UNKNOWN,
LTTV_STATE_HOOKS,
LTTV_STATE_NAME_TABLES,
LTTV_STATE_TRACE_STATE_USE_COUNT,
- LTTV_STATE_RESOURCE_CPUS;
+ LTTV_STATE_RESOURCE_CPUS,
+ LTTV_STATE_RESOURCE_IRQS,
+ LTTV_STATE_RESOURCE_BLKDEVS;
static void create_max_time(LttvTraceState *tcs);
static void lttv_trace_states_read_raw(LttvTraceState *tcs, FILE *fp,
GPtrArray *quarktable);
+/* Resource function prototypes */
+static LttvBdevState *get_hashed_bdevstate(LttvTraceState *ts, guint16 devcode);
+static LttvBdevState *bdevstate_new(void);
+static void bdevstate_free(LttvBdevState *);
+static void bdevstate_free_cb(gpointer key, gpointer value, gpointer user_data);
+static LttvBdevState *bdevstate_copy(LttvBdevState *bds);
+static LttvBdevState *bdev_state_get(LttvTraceState *ts, guint16 devcode);
+
+
void lttv_state_save(LttvTraceState *self, LttvAttribute *container)
{
LTTV_TRACE_STATE_GET_CLASS(self)->state_save(self, container);
static void
restore_init_state(LttvTraceState *self)
{
- guint i, nb_cpus;
+ guint i, nb_cpus, nb_irqs;
- LttvTracefileState *tfcs;
+ //LttvTracefileState *tfcs;
LttTime start_time, end_time;
//lttv_process_trace_seek_time(&self->parent, ltt_time_zero);
nb_cpus = ltt_trace_get_num_cpu(self->parent.t);
+ nb_irqs = self->nb_irqs;
/* Put the per cpu running_process to beginning state : process 0. */
for(i=0; i< nb_cpus; i++) {
//self->running_process[i]->state->s = LTTV_STATE_RUN;
self->running_process[i]->cpu = i;
+
+ /* reset cpu states */
+ if(self->cpu_states[i].mode_stack->len > 0)
+ g_array_remove_range(self->cpu_states[i].mode_stack, 0, self->cpu_states[i].mode_stack->len);
}
+
+ /* reset irq states */
+ for(i=0; i<nb_irqs; i++) {
+ if(self->irq_states[i].mode_stack->len > 0)
+ g_array_remove_range(self->irq_states[i].mode_stack, 0, self->irq_states[i].mode_stack->len);
+ }
+
+ /* reset bdev states */
+ g_hash_table_foreach(self->bdev_states, bdevstate_free_cb, NULL);
+ g_hash_table_steal_all(self->bdev_states);
#if 0
nb_tracefile = self->parent.tracefiles->len;
{
FILE *fp;
GPtrArray *quarktable;
- char *trace_path;
+ const char *trace_path;
char path[PATH_MAX];
guint count;
guint i;
LttvTraceState *tcs;
- LttvTracefileState *tfcs;
+ //LttvTracefileState *tfcs;
LttvAttributeValue v;
}
for(i = 0 ; i < process->user_stack->len; i++) {
- address = &g_array_index(process->user_stack, guint64, i);
+ address = g_array_index(process->user_stack, guint64, i);
fprintf(fp, " <USER_STACK ADDRESS=\"%llu\"/>\n",
address);
}
}
for(i = 0 ; i < process->user_stack->len; i++) {
- address = &g_array_index(process->user_stack, guint64, i);
+ address = g_array_index(process->user_stack, guint64, i);
fputc(HDR_USER_STACK, fp);
fwrite(&address, sizeof(address), 1, fp);
#if 0
LttvProcessState tmp;
GQuark tmpq;
- guint i;
guint64 *address;
- guint cpu;
/* TODO : check return value */
fread(&tmp.type, sizeof(tmp.type), 1, fp);
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, ltt_time_zero);
+ lttv_process_trace_seek_time(&tcs->parent, ltt_time_zero);
return;
}
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, FALSE);
+ }
+
+ 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, FALSE);
+ 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
static void state_save(LttvTraceState *self, LttvAttribute *container)
{
- guint i, nb_tracefile, nb_cpus;
+ guint i, nb_tracefile, nb_cpus, nb_irqs;
LttvTracefileState *tfcs;
guint *running_process;
- LttvAttributeType type;
-
LttvAttributeValue value;
- LttvAttributeName name;
-
LttEventPosition *ep;
tracefiles_tree = lttv_attribute_find_subdir(container,
}
}
- value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_CPUS,
- LTTV_POINTER);
- guint size = sizeof(LttvCPUState)*nb_cpus;
- *(value.v_pointer) = lttv_state_copy_cpu_states(self->cpu_states, nb_cpus);
+ /* save the cpu state */
+ {
+ 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 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;
+ guint i, nb_tracefile, pid, nb_cpus, nb_irqs;
LttvTracefileState *tfcs;
g_assert(self->running_process[i] != NULL);
}
- printf("state restore\n");
-
nb_tracefile = self->parent.tracefiles->len;
//g_tree_destroy(tsc->pqueue);
lttv_state_free_cpu_states(self->cpu_states, nb_cpus);
self->cpu_states = lttv_state_copy_cpu_states(*(value.v_pointer), nb_cpus);
+ /* restore irq resource states */
+ nb_irqs = self->nb_irqs;
+ type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_IRQS, &value);
+ g_assert(type == LTTV_POINTER);
+ lttv_state_free_irq_states(self->irq_states, nb_irqs);
+ self->irq_states = lttv_state_copy_irq_states(*(value.v_pointer), nb_irqs);
+
+ /* restore the blkdev states */
+ type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_BLKDEVS, &value);
+ g_assert(type == LTTV_POINTER);
+ lttv_state_free_blkdev_hashtable(self->bdev_states);
+ self->bdev_states = lttv_state_copy_blkdev_hashtable(*(value.v_pointer));
+
for(i = 0 ; i < nb_tracefile ; i++) {
tfcs =
LTTV_TRACEFILE_STATE(g_array_index(self->parent.tracefiles,
gboolean is_named;
- LttEventPosition *ep;
-
tracefiles_tree = lttv_attribute_find_subdir(container,
LTTV_STATE_TRACEFILES);
g_object_ref(G_OBJECT(tracefiles_tree));
{
int i, nb;
- GQuark f_name, e_name;
-
LttvTraceHook h;
- LttvTraceHookByFacility *thf;
-
- LttEventType *et;
-
LttType *t;
GString *fe_name = g_string_new("");
LTTV_POINTER, &v);
g_assert(*(v.v_pointer) == NULL);
*(v.v_pointer) = name_tables;
-#if 0 // Use iteration over the facilities_by_name and then list all event
- // types of each facility
- nb = ltt_trace_eventtype_number(tcs->parent.t);
- name_tables->eventtype_names = g_new(GQuark, nb);
- for(i = 0 ; i < nb ; i++) {
- et = ltt_trace_eventtype_get(tcs->parent.t, i);
- e_name = ltt_eventtype_name(et);
- f_name = ltt_facility_name(ltt_eventtype_facility(et));
- g_string_printf(fe_name, "%s.%s", f_name, e_name);
- name_tables->eventtype_names[i] = g_quark_from_string(fe_name->str);
- }
-#endif //0
+
if(!lttv_trace_find_hook(tcs->parent.t,
- LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY,
+ LTT_EVENT_SYSCALL_ENTRY,
LTT_FIELD_SYSCALL_ID, 0, 0,
NULL, NULL, &h)) {
name_tables->nb_syscalls = 0;
}
- if(!lttv_trace_find_hook(tcs->parent.t, LTT_FACILITY_KERNEL_ARCH,
+ if(!lttv_trace_find_hook(tcs->parent.t,
LTT_EVENT_TRAP_ENTRY,
LTT_FIELD_TRAP_ID, 0, 0,
NULL, NULL, &h)) {
}
if(!lttv_trace_find_hook(tcs->parent.t,
- LTT_FACILITY_KERNEL, LTT_EVENT_IRQ_ENTRY,
+ LTT_EVENT_IRQ_ENTRY,
LTT_FIELD_IRQ_ID, 0, 0,
NULL, NULL, &h)) {
static void cpu_pop_mode(LttvCPUState *cpust)
{
- if(cpust->mode_stack->len == 1)
+ if(cpust->mode_stack->len <= 1)
cpu_set_base_mode(cpust, LTTV_CPU_UNKNOWN);
else
g_array_set_size(cpust->mode_stack, cpust->mode_stack->len - 1);
static void bdev_pop_mode(LttvBdevState *bdevst)
{
- if(bdevst->mode_stack->len == 1)
+ if(bdevst->mode_stack->len <= 1)
bdev_set_base_mode(bdevst, LTTV_BDEV_UNKNOWN);
else
g_array_set_size(bdevst->mode_stack, bdevst->mode_stack->len - 1);
static void irq_pop_mode(LttvIRQState *irqst)
{
- if(irqst->mode_stack->len == 1)
+ if(irqst->mode_stack->len <= 1)
irq_set_base_mode(irqst, LTTV_IRQ_UNKNOWN);
else
g_array_set_size(irqst->mode_stack, irqst->mode_stack->len - 1);
int lttv_state_pop_state_cleanup(LttvProcessState *process,
LttvTracefileState *tfs)
{
- guint cpu = tfs->cpu;
- LttvTraceState *ts = (LttvTraceState*)tfs->parent.t_context;
-
guint depth = process->execution_stack->len;
if(depth == 1){
/* Get smaller keys */
if(res->best) {
if(ltt_time_compare(*elem_time, *res->best) < 0) {
- res->best = elem_time;
+ res->best = (LttTime *)elem_time;
}
} else {
- res->best = elem_time;
+ res->best = (LttTime *)elem_time;
}
return -1;
}
LttvExecutionState *es;
- LttvTraceContext *tc = (LttvTraceContext*)tcs;
-
char buffer[128];
process->pid = pid;
return FALSE;
}
-LttvBdevState *bdev_state_get(LttvTraceState *ts, guint16 devcode)
+static gboolean enum_interrupt(void *hook_data, void *call_data)
{
- 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));
+ LttvTracefileState *s = (LttvTracefileState *)call_data;
+ LttvTraceState *ts = (LttvTraceState *)s->parent.t_context;
+ LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+ guint8 fac_id = ltt_event_facility_id(e);
+ guint8 ev_id = ltt_event_eventtype_id(e);
+ LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
- gint * key = g_malloc(sizeof(gint));
- *key = devcode;
- g_hash_table_insert(ts->bdev_states, key, bdevstate);
- printf("adding key %u to hash table\n", *key);
+ GQuark action = g_quark_from_string(ltt_event_get_string(e, thf->f1));
+ guint irq = ltt_event_get_long_unsigned(e, thf->f2);
- bdev = bdevstate;
- }
+ ts->irq_names[irq] = action;
- return bdev;
+ return FALSE;
}
+
static gboolean bdev_request_issue(void *hook_data, void *call_data)
{
LttvTracefileState *s = (LttvTracefileState *)call_data;
guint16 devcode = MKDEV(major,minor);
/* have we seen this block device before? */
- gpointer bdev = bdev_state_get(ts, devcode);
+ gpointer bdev = get_hashed_bdevstate(ts, devcode);
if(oper == 0)
bdev_push_mode(bdev, LTTV_BDEV_BUSY_READING);
guint16 devcode = MKDEV(major,minor);
/* have we seen this block device before? */
- gpointer bdev = bdev_state_get(ts, devcode);
+ gpointer bdev = get_hashed_bdevstate(ts, devcode);
/* update block device */
bdev_pop_mode(bdev);
statedump_end, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
if(ret) hn--;
+ ret = lttv_trace_find_hook(ts->parent.t,
+ LTT_FACILITY_LIST, LTT_EVENT_LIST_INTERRUPT,
+ LTT_FIELD_ACTION, LTT_FIELD_NUM, 0,
+ enum_interrupt, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+ if(ret) hn--;
+
ret = lttv_trace_find_hook(ts->parent.t,
LTT_FACILITY_BLOCK, LTT_EVENT_REQUEST_ISSUE,
LTT_FIELD_MAJOR, LTT_FIELD_MINOR, LTT_FIELD_OPERATION,
LTTV_STATE_TRACE_STATE_USE_COUNT =
g_quark_from_string("trace_state_use_count");
LTTV_STATE_RESOURCE_CPUS = g_quark_from_string("cpu resource states");
+ LTTV_STATE_RESOURCE_IRQS = g_quark_from_string("irq resource states");
+ LTTV_STATE_RESOURCE_BLKDEVS = g_quark_from_string("blkdevs resource states");
LTT_FACILITY_KERNEL = g_quark_from_string("kernel");
LTT_EVENT_THREAD_BRAND = g_quark_from_string("thread_brand");
LTT_EVENT_REQUEST_ISSUE = g_quark_from_string("_blk_request_issue");
LTT_EVENT_REQUEST_COMPLETE = g_quark_from_string("_blk_request_complete");
+ LTT_EVENT_LIST_INTERRUPT = g_quark_from_string("interrupt");;
LTT_FIELD_SYSCALL_ID = g_quark_from_string("syscall_id");
LTT_FIELD_MAJOR = g_quark_from_string("major");
LTT_FIELD_MINOR = g_quark_from_string("minor");
LTT_FIELD_OPERATION = g_quark_from_string("direction");
+ LTT_FIELD_ACTION = g_quark_from_string("action");
+ LTT_FIELD_NUM = g_quark_from_string("num");
LTTV_CPU_UNKNOWN = g_quark_from_string("unknown");
LTTV_CPU_IDLE = g_quark_from_string("idle");
projects / lttv.git / blobdiff