[lttv.git] / ltt / branches / poly / lttv / state.c


#include <lttv/state.h>
#include <ltt/facility.h>
#include <ltt/trace.h>

LttvInterruptType
  LTTV_STATE_USER_MODE,
  LTTV_STATE_SYSCALL,
  LTTV_STATE_TRAP,
  LTTV_STATE_IRQ;


LttvProcessStatus
  LTTV_STATE_UNNAMED,
  LTTV_STATE_WAIT_FORK,
  LTTV_STATE_WAIT_CPU,
  LTTV_STATE_EXIT,
  LTTV_STATE_WAIT,
  LTTV_STATE_RUN;

static GQuark
  LTTV_STATE_HOOKS;

void remove_all_processes(GHashTable *processes);


static void
init(LttvTracesetState *self, LttvTraceset *ts)
{
  guint i, j, nb_trace, nb_tracefile;

  LttvTraceContext *tc;

  LttvTraceState *tcs;

  LttvTracefileContext *tfc;

  LttvTracefileState *tfcs;

  LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek_parent(LTTV_TRACESET_STATE_GET_CLASS(self)))->init((LttvTracesetContext *)self, ts);

  nb_trace = lttv_traceset_number(ts);
  for(i = 0 ; i < nb_trace ; i++) {
    tcs = (LttvTraceState *)tc = (LTTV_TRACESET_CONTEXT(self)->traces[i]);
    tcs->processes = g_hash_table_new(g_direct_hash, g_direct_equal);

    nb_tracefile = ltt_trace_control_tracefile_number(tc->t);
    for(j = 0 ; j < nb_tracefile ; j++) {
      tfcs = (LttvTracefileState *)tfc = tc->control_tracefiles[j];
      tfcs->process = NULL;
    }

    nb_tracefile = ltt_trace_per_cpu_tracefile_number(tc->t);
    for(j = 0 ; j < nb_tracefile ; j++) {
      tfcs = (LttvTracefileState *)tfc = tc->per_cpu_tracefiles[j];
      tfcs->process = NULL;
    }
  }
}


static void
fini(LttvTracesetState *self)
{
  guint i, j, nb_trace, nb_tracefile;

  LttvTraceState *tcs;

  LttvTracefileState *tfcs;

  nb_trace = lttv_traceset_number(LTTV_TRACESET_CONTEXT(self)->ts);
  for(i = 0 ; i < nb_trace ; i++) {
    tcs = (LttvTraceState *)(LTTV_TRACESET_CONTEXT(self)->traces[i]);
    remove_all_processes(tcs->processes);
    g_hash_table_destroy(tcs->processes);
  }
  LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek_parent(LTTV_TRACESET_STATE_GET_CLASS(self)))->fini((LttvTracesetContext *)self);
}


LttvTracesetContext *
new_traceset_context(LttvTracesetContext *self)
{
  return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE, NULL));
}


LttvTraceContext * 
new_trace_context(LttvTracesetContext *self)
{
  return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE, NULL));
}


LttvTracefileContext *
new_tracefile_context(LttvTracesetContext *self)
{
  return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE, NULL));
}


static void
traceset_state_instance_init (GTypeInstance *instance, gpointer g_class)
{
}


static void
traceset_state_finalize (LttvTracesetContext *self)
{
  G_OBJECT_CLASS(g_type_class_peek_parent(LTTV_TRACESET_STATE_GET_CLASS(self)))->finalize(G_OBJECT(self));
}


static void
traceset_state_class_init (LttvTracesetContextClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS(klass);

  gobject_class->finalize = (void (*)(GObject *self)) traceset_state_finalize;
  klass->init = (void (*)(LttvTracesetContext *self, LttvTraceset *ts))init;
  klass->fini = (void (*)(LttvTracesetContext *self))fini;
  klass->new_traceset_context = new_traceset_context;
  klass->new_trace_context = new_trace_context;
  klass->new_tracefile_context = new_tracefile_context;
}


GType 
lttv_traceset_state_get_type(void)
{
  static GType type = 0;
  if (type == 0) {
    static const GTypeInfo info = {
      sizeof (LttvTracesetStateClass),
      NULL,   /* base_init */
      NULL,   /* base_finalize */
      (GClassInitFunc) traceset_state_class_init,   /* class_init */
      NULL,   /* class_finalize */
      NULL,   /* class_data */
      sizeof (LttvTracesetContext),
      0,      /* n_preallocs */
      (GInstanceInitFunc) traceset_state_instance_init    /* instance_init */
    };

    type = g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE, "LttvTracesetStateType", 
        &info, 0);
  }
  return type;
}


static void
trace_state_instance_init (GTypeInstance *instance, gpointer g_class)
{
}


static void
trace_state_finalize (LttvTraceContext *self)
{
  G_OBJECT_CLASS(g_type_class_peek_parent(LTTV_TRACE_STATE_GET_CLASS(self)))->finalize(G_OBJECT(self));
}


static void
trace_state_class_init (LttvTraceContextClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS(klass);

  gobject_class->finalize = (void (*)(GObject *self)) trace_state_finalize;
}


GType 
lttv_trace_state_get_type(void)
{
  static GType type = 0;
  if (type == 0) {
    static const GTypeInfo info = {
      sizeof (LttvTraceStateClass),
      NULL,   /* base_init */
      NULL,   /* base_finalize */
      (GClassInitFunc) trace_state_class_init,   /* class_init */
      NULL,   /* class_finalize */
      NULL,   /* class_data */
      sizeof (LttvTracesetState),
      0,      /* n_preallocs */
      (GInstanceInitFunc) trace_state_instance_init    /* instance_init */
    };

    type = g_type_register_static (LTTV_TRACE_CONTEXT_TYPE, 
        "LttvTraceStateType", &info, 0);
  }
  return type;
}


static void
tracefile_state_instance_init (GTypeInstance *instance, gpointer g_class)
{
}


static void
tracefile_state_finalize (LttvTracefileState *self)
{
  G_OBJECT_CLASS(g_type_class_peek_parent(LTTV_TRACEFILE_STATE_GET_CLASS(self)))->finalize(G_OBJECT(self));
}


static void
tracefile_state_class_init (LttvTracefileStateClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS(klass);

  gobject_class->finalize = (void (*)(GObject *self)) tracefile_state_finalize;
}


GType 
lttv_tracefile_state_get_type(void)
{
  static GType type = 0;
  if (type == 0) {
    static const GTypeInfo info = {
      sizeof (LttvTracefileStateClass),
      NULL,   /* base_init */
      NULL,   /* base_finalize */
      (GClassInitFunc) tracefile_state_class_init,   /* class_init */
      NULL,   /* class_finalize */
      NULL,   /* class_data */
      sizeof (LttvTracefileState),
      0,      /* n_preallocs */
      (GInstanceInitFunc) tracefile_state_instance_init    /* instance_init */
    };

    type = g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE, 
        "LttvTracefileStateType", &info, 0);
  }
  return type;
}


struct HookData {
  LttField *f1;
  LttField *f2;
  LttField *f3;
};


struct HookId {
  LttvHook h;
  guint id;
  void *hook_data;
  gboolean free_hook_data;
};


static void push_state(LttvTracefileState *tfs, LttvInterruptType t, 
    guint state_id)
{
  LttvInterruptState *intr;

  LttvProcessState *process = tfs->process;

  guint depth = process->interrupt_stack->len;

  g_array_set_size(process->interrupt_stack, depth + 1);
  intr = &g_array_index(process->interrupt_stack, LttvInterruptState, depth);
  intr->t = t;
  intr->n = state_id;
  intr->entry = intr->last_change = LTTV_TRACEFILE_CONTEXT(tfs)->timestamp;
  intr->s = process->state->s;
}


static void pop_state(LttvTracefileState *tfs, LttvInterruptType t)
{
  LttvProcessState *process = tfs->process;

  guint depth = process->interrupt_stack->len - 1;

  g_assert(process->state->t == t);
  g_array_remove_index(process->interrupt_stack, depth);
  depth--;
  process->state = &g_array_index(process->interrupt_stack, LttvInterruptState,
      depth);
}


LttvProcessState *create_process(LttvTracefileState *tfs, 
    LttvProcessState *parent, guint pid)
{
  LttvProcessState *process = g_new(LttvProcessState, 1);

  LttvInterruptState *intr;

  LttvTraceContext *tc;

  LttvTraceState *tcs;

  LttvTracefileContext *tfc = LTTV_TRACEFILE_CONTEXT(tfs);

  tcs = (LttvTraceState *)tc = tfc->t_context;

  g_hash_table_insert(tcs->processes, GUINT_TO_POINTER(pid), process);
  process->pid = pid;
  process->birth = tfc->timestamp;
  process->name = LTTV_STATE_UNNAMED;
  process->interrupt_stack = g_array_new(FALSE, FALSE, 
      sizeof(LttvInterruptState));
  g_array_set_size(process->interrupt_stack, 1);
  intr = process->state = &g_array_index(process->interrupt_stack, 
      LttvInterruptState, 0);
  intr->t = LTTV_STATE_USER_MODE;
  intr->n = 0;
  intr->entry = tfc->timestamp;
  intr->last_change = tfc->timestamp;
  intr->s = LTTV_STATE_WAIT_FORK;
}


LttvProcessState *find_process(LttvTracefileState *tfs, guint pid)
{
  LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
  LttvProcessState *process = g_hash_table_lookup(ts->processes, 
      GUINT_TO_POINTER(pid));
  if(process == NULL) process = create_process(tfs, NULL, pid);
  return process;
}


void exit_process(LttvTracefileState *tfs, LttvProcessState *process) 
{
  LttvTraceState *ts = LTTV_TRACE_STATE(tfs->parent.t_context);

  g_hash_table_remove(ts->processes, GUINT_TO_POINTER(process->pid));
  g_array_free(process->interrupt_stack, TRUE);
  g_free(process);
}


void free_process_state(gpointer key, gpointer value, gpointer user_data)
{
  g_array_free(((LttvProcessState *)value)->interrupt_stack, TRUE);
  g_free(value);
}


void remove_all_processes(GHashTable *processes)
{
  g_hash_table_foreach(processes, free_process_state, NULL);
}


gboolean syscall_entry(void *hook_data, void *call_data)
{
  LttField *f = (LttField *)hook_data;

  LttvTracefileState *s = (LttvTracefileState *)call_data;

  push_state(s, LTTV_STATE_SYSCALL, ltt_event_get_unsigned(
      LTTV_TRACEFILE_CONTEXT(s)->e, f));
  return FALSE;
}


gboolean syscall_exit(void *hook_data, void *call_data)
{
  LttvTracefileState *s = (LttvTracefileState *)call_data;

  pop_state(s, LTTV_STATE_SYSCALL);
  return FALSE;
}


gboolean trap_entry(void *hook_data, void *call_data)
{
  LttField *f = (LttField *)hook_data;

  LttvTracefileState *s = (LttvTracefileState *)call_data;

  push_state(s, LTTV_STATE_TRAP, ltt_event_get_unsigned(s->parent.e, f));
  return FALSE;
}


gboolean trap_exit(void *hook_data, void *call_data)
{
  LttvTracefileState *s = (LttvTracefileState *)call_data;

  pop_state(s, LTTV_STATE_TRAP);
  return FALSE;
}


gboolean irq_entry(void *hook_data, void *call_data)
{
  LttField *f = (LttField *)hook_data;

  LttvTracefileState *s = (LttvTracefileState *)call_data;

  /* Do something with the info about being in user or system mode when int? */
  push_state(s, LTTV_STATE_IRQ, ltt_event_get_unsigned(s->parent.e, f));
  return FALSE;
}


gboolean irq_exit(void *hook_data, void *call_data)
{
  LttvTracefileState *s = (LttvTracefileState *)call_data;

  pop_state(s, LTTV_STATE_IRQ);
  return FALSE;
}


gboolean schedchange(void *hook_data, void *call_data)
{
  struct HookData *h = (struct HookData *)hook_data;

  LttvTracefileState *s = (LttvTracefileState *)call_data;

  guint pid_in, pid_out, state_out;

  pid_in = ltt_event_get_int(s->parent.e, h->f1);
  pid_out = ltt_event_get_int(s->parent.e, h->f2);
  state_out = ltt_event_get_int(s->parent.e, h->f3);
  if(s->process != NULL) {
    if(state_out == 0) s->process->state->s = LTTV_STATE_WAIT_CPU;
    else if(s->process->state->s == LTTV_STATE_EXIT) 
        exit_process(s, s->process);
    else s->process->state->s = LTTV_STATE_WAIT;
  }
  s->process = find_process(s, pid_in);
  s->process->state->s = LTTV_STATE_RUN;
  return FALSE;
}


gboolean process_fork(void *hook_data, void *call_data)
{
  LttField *f = (LttField *)hook_data;

  LttvTracefileState *s = (LttvTracefileState *)call_data;

  guint child_pid;

  child_pid = ltt_event_get_int(s->parent.e, f);
  create_process(s, s->process, child_pid);
  return FALSE;
}


gboolean process_exit(void *hook_data, void *call_data)
{
  LttvTracefileState *s = (LttvTracefileState *)call_data;

  if(s->process != NULL) {
    s->process->state->s = LTTV_STATE_EXIT;
  }
  return FALSE;
}


static LttField *
find_field(LttEventType *et, const char *field)
{
  LttType *t;

  LttField *f;

  guint i, nb;

  char *name;

  if(field == NULL) return NULL;

  f = ltt_eventtype_field(et);
  t = ltt_eventtype_type(et);
  g_assert(ltt_type_class(t) == LTT_STRUCT);
  nb = ltt_type_member_number(t);
  for(i = 0 ; i < nb ; i++) {
    ltt_type_member_type(t, i, &name);
    if(strcmp(name, field) == 0) break;
  }
  g_assert(i < nb);
  return ltt_field_member(f, i);
}


static struct HookId
find_hook(LttTrace *t, char *facility, char *event, 
    char *field1, char *field2, char *field3, LttvHook h)
{
  LttFacility *f;

  LttEventType *et;

  guint nb, pos, i;

  struct HookId hook_id;

  struct HookData hook_data, *phook_data;

  char *name;

  nb = ltt_trace_facility_find(t, facility, &pos);
  if(nb < 1) g_error("No %s facility", facility);
  f = ltt_trace_facility_get(t, pos);
  et = ltt_facility_eventtype_get_by_name(f, event);
  if(et == NULL) g_error("Event %s does not exist", event);

  hook_id.id = *(ltt_eventtype_id(et)); /* CHECK */
  hook_id.h = h;
  hook_id.free_hook_data = FALSE;
  hook_data.f1 = find_field(et, field1);
  hook_data.f2 = find_field(et, field2);
  hook_data.f3 = find_field(et, field3);
  if(hook_data.f1 == NULL) hook_id.hook_data = NULL;
  else if(hook_data.f2 == NULL) hook_id.hook_data = hook_data.f1;
  else {
    phook_data = g_new(struct HookData, 1);
    *phook_data = hook_data;
    hook_id.hook_data = phook_data;
    hook_id.free_hook_data = TRUE;
  }
  return hook_id;
}


lttv_state_add_event_hooks(LttvTracesetState *self)
{
  LttvTraceset *traceset = self->parent.ts;

  guint i, j, k, nb_trace, nb_control, nb_per_cpu, nb_tracefile;

  LttFacility *f;

  LttEventType *et;

  LttvTraceState *ts;

  LttvTracefileState *tfs;

  void *hook_data;

  GArray *hooks;

  struct HookId hook_id;

  LttvAttributeValue val;

  nb_trace = lttv_traceset_number(traceset);
  for(i = 0 ; i < nb_trace ; i++) {
    ts = (LttvTraceState *)self->parent.traces[i];

    /* Find the eventtype id for the following events and register the
       associated by id hooks. */

    hooks = g_array_new(FALSE, FALSE, sizeof(struct HookId));
    g_array_add(hooks, find_hook(ts->parent.t, "core","syscall_entry", 
        "syscall_id", NULL, NULL, syscall_entry));
    g_array_add(hooks, find_hook(ts->parent.t, "core", "syscall_exit", 
        NULL, NULL, NULL, syscall_exit));
    g_array_add(hooks, find_hook(ts->parent.t, "core", "trap_entry", "trap_id",
        NULL, NULL, trap_entry));
    g_array_add(hooks, find_hook(ts->parent.t, "core", "trap_exit", NULL, NULL,
        NULL, trap_exit));
    g_array_add(hooks, find_hook(ts->parent.t, "core", "irq_entry", "irq_id",
        NULL, NULL, irq_entry));
    g_array_add(hooks, find_hook(ts->parent.t, "core", "irq_exit", NULL, NULL,
        NULL, irq_exit));
    g_array_add(hooks, find_hook(ts->parent.t, "core", "schedchange", 
        "in", "out", "out_state", schedchange));
    g_array_add(hooks, find_hook(ts->parent.t, "core", "process_fork", 
        "child_pid", NULL, NULL, process_fork));
    g_array_add(hooks, find_hook(ts->parent.t, "core", "process_exit", 
        NULL, NULL, NULL, process_exit));

    /* Add these hooks to each before_event_by_id hooks list */

    nb_control = ltt_trace_control_tracefile_number(ts->parent.t);
    nb_per_cpu = ltt_trace_control_tracefile_number(ts->parent.t);
    nb_tracefile = nb_control + nb_per_cpu;
    for(j = 0 ; j < nb_tracefile ; j++) {
      if(j < nb_control) {
        tfs = LTTV_TRACEFILE_STATE(ts->parent.control_tracefiles[j]);
      }
      else {
        tfs = LTTV_TRACEFILE_STATE(ts->parent.per_cpu_tracefiles[j]);
      }

      for(k = 0 ; k < hooks->len ; k++) {
        hook_id = g_array_index(hooks, struct HookId, k);
        lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.before_event_by_id, 
	  hook_id.id), hook_id.h, hook_id.hook_data);
      }
    }
    lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
    *(val.v_pointer) = hooks;
  }
}


lttv_state_remove_event_hooks(LttvTracesetState *self)
{
  LttvTraceset *traceset = self->parent.ts;

  guint i, j, k, nb_trace, nb_control, nb_per_cpu, nb_tracefile;

  LttvTraceState *ts;

  LttvTracefileState *tfs;

  void *hook_data;

  GArray *hooks;

  struct HookId hook_id;

  LttvAttributeValue val;

  nb_trace = lttv_traceset_number(traceset);
  for(i = 0 ; i < nb_trace ; i++) {
    ts = LTTV_TRACE_STATE(self->parent.traces[i]);
    lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
    hooks = *(val.v_pointer);

    /* Add these hooks to each before_event_by_id hooks list */

    nb_control = ltt_trace_control_tracefile_number(ts->parent.t);
    nb_per_cpu = ltt_trace_control_tracefile_number(ts->parent.t);
    nb_tracefile = nb_control + nb_per_cpu;
    for(j = 0 ; j < nb_tracefile ; j++) {
      if(j < nb_control) {
        tfs = LTTV_TRACEFILE_STATE(ts->parent.control_tracefiles[j]);
      }
      else {
        tfs = LTTV_TRACEFILE_STATE(ts->parent.per_cpu_tracefiles[j]);
      }

      for(k = 0 ; k < hooks->len ; k++) {
        hook_id = g_array_index(hooks, struct HookId, k);
        lttv_hooks_remove_data(
            lttv_hooks_by_id_find(tfs->parent.before_event_by_id, 
	    hook_id.id), hook_id.h, hook_id.hook_data);

      }
      for(k = 0 ; k < hooks->len ; k++) {
        hook_id = g_array_index(hooks, struct HookId, k);
        if(hook_id.free_hook_data) g_free(hook_id.hook_data);
      }
    }
    g_array_free(hooks, TRUE);
  }
}


void lttv_state_init(int argc, char **argv)
{
  LTTV_STATE_UNNAMED = g_quark_from_string("unnamed");
  LTTV_STATE_USER_MODE = g_quark_from_string("user mode");
  LTTV_STATE_WAIT_FORK = g_quark_from_string("wait fork");
  LTTV_STATE_SYSCALL = g_quark_from_string("system call");
  LTTV_STATE_TRAP = g_quark_from_string("trap");
  LTTV_STATE_IRQ = g_quark_from_string("irq");
  LTTV_STATE_WAIT_CPU = g_quark_from_string("wait for cpu");
  LTTV_STATE_EXIT = g_quark_from_string("exiting");
  LTTV_STATE_WAIT = g_quark_from_string("wait for I/O");
  LTTV_STATE_RUN = g_quark_from_string("running");
  LTTV_STATE_HOOKS = g_quark_from_string("saved state hooks");
}

void lttv_state_destroy() 
{
}
Commit	Line	Data
dc877563	1
dc877563	2	#include <lttv/state.h>
ba576a78	3	#include <ltt/facility.h>
ba576a78	4	#include <ltt/trace.h>
dc877563	5
ffd54a90	6	LttvInterruptType
	7	LTTV_STATE_USER_MODE,
	8	LTTV_STATE_SYSCALL,
	9	LTTV_STATE_TRAP,
	10	LTTV_STATE_IRQ;
	11
	12
	13	LttvProcessStatus
	14	LTTV_STATE_UNNAMED,
	15	LTTV_STATE_WAIT_FORK,
	16	LTTV_STATE_WAIT_CPU,
	17	LTTV_STATE_EXIT,
	18	LTTV_STATE_WAIT,
	19	LTTV_STATE_RUN;
	20
ba576a78	21	static GQuark
	22	LTTV_STATE_HOOKS;
	23
	24	void remove_all_processes(GHashTable *processes);
	25
dc877563	26
	27	static void
	28	init(LttvTracesetState self, LttvTraceset ts)
	29	{
	30	guint i, j, nb_trace, nb_tracefile;
	31
ffd54a90	32	LttvTraceContext *tc;
dc877563	33
ffd54a90	34	LttvTraceState *tcs;
	35
	36	LttvTracefileContext *tfc;
dc877563	37
ffd54a90	38	LttvTracefileState *tfcs;
	39
	40	LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek_parent(LTTV_TRACESET_STATE_GET_CLASS(self)))->init((LttvTracesetContext *)self, ts);
dc877563	41
	42	nb_trace = lttv_traceset_number(ts);
	43	for(i = 0 ; i < nb_trace ; i++) {
ffd54a90	44	tcs = (LttvTraceState *)tc = (LTTV_TRACESET_CONTEXT(self)->traces[i]);
ffd54a90	45	tcs->processes = g_hash_table_new(g_direct_hash, g_direct_equal);
dc877563	46
	47	nb_tracefile = ltt_trace_control_tracefile_number(tc->t);
	48	for(j = 0 ; j < nb_tracefile ; j++) {
ffd54a90	49	tfcs = (LttvTracefileState *)tfc = tc->control_tracefiles[j];
ffd54a90	50	tfcs->process = NULL;
dc877563	51	}
	52
	53	nb_tracefile = ltt_trace_per_cpu_tracefile_number(tc->t);
	54	for(j = 0 ; j < nb_tracefile ; j++) {
ffd54a90	55	tfcs = (LttvTracefileState *)tfc = tc->per_cpu_tracefiles[j];
ffd54a90	56	tfcs->process = NULL;
dc877563	57	}
	58	}
	59	}
	60
	61
	62	static void
	63	fini(LttvTracesetState *self)
	64	{
	65	guint i, j, nb_trace, nb_tracefile;
	66
ffd54a90	67	LttvTraceState *tcs;
dc877563	68
ffd54a90	69	LttvTracefileState *tfcs;
dc877563	70
ffd54a90	71	nb_trace = lttv_traceset_number(LTTV_TRACESET_CONTEXT(self)->ts);
dc877563	72	for(i = 0 ; i < nb_trace ; i++) {
ffd54a90	73	tcs = (LttvTraceState *)(LTTV_TRACESET_CONTEXT(self)->traces[i]);
	74	remove_all_processes(tcs->processes);
	75	g_hash_table_destroy(tcs->processes);
dc877563	76	}
ffd54a90	77	LTTV_TRACESET_CONTEXT_CLASS(g_type_class_peek_parent(LTTV_TRACESET_STATE_GET_CLASS(self)))->fini((LttvTracesetContext *)self);
dc877563	78	}
	79
	80
	81	LttvTracesetContext *
	82	new_traceset_context(LttvTracesetContext *self)
	83	{
ffd54a90	84	return LTTV_TRACESET_CONTEXT(g_object_new(LTTV_TRACESET_STATE_TYPE, NULL));
dc877563	85	}
	86
	87
	88	LttvTraceContext *
	89	new_trace_context(LttvTracesetContext *self)
	90	{
ffd54a90	91	return LTTV_TRACE_CONTEXT(g_object_new(LTTV_TRACE_STATE_TYPE, NULL));
dc877563	92	}
	93
	94
	95	LttvTracefileContext *
	96	new_tracefile_context(LttvTracesetContext *self)
	97	{
ffd54a90	98	return LTTV_TRACEFILE_CONTEXT(g_object_new(LTTV_TRACEFILE_STATE_TYPE, NULL));
	99	}
	100
	101
	102	static void
	103	traceset_state_instance_init (GTypeInstance *instance, gpointer g_class)
	104	{
	105	}
	106
	107
	108	static void
	109	traceset_state_finalize (LttvTracesetContext *self)
	110	{
	111	G_OBJECT_CLASS(g_type_class_peek_parent(LTTV_TRACESET_STATE_GET_CLASS(self)))->finalize(G_OBJECT(self));
	112	}
	113
	114
	115	static void
	116	traceset_state_class_init (LttvTracesetContextClass *klass)
	117	{
	118	GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
	119
	120	gobject_class->finalize = (void ()(GObject self)) traceset_state_finalize;
	121	klass->init = (void ()(LttvTracesetContext self, LttvTraceset *ts))init;
	122	klass->fini = (void ()(LttvTracesetContext self))fini;
	123	klass->new_traceset_context = new_traceset_context;
	124	klass->new_trace_context = new_trace_context;
	125	klass->new_tracefile_context = new_tracefile_context;
dc877563	126	}
	127
	128
	129	GType
	130	lttv_traceset_state_get_type(void)
	131	{
	132	static GType type = 0;
	133	if (type == 0) {
	134	static const GTypeInfo info = {
	135	sizeof (LttvTracesetStateClass),
	136	NULL, /* base_init */
	137	NULL, /* base_finalize */
ffd54a90	138	(GClassInitFunc) traceset_state_class_init, /* class_init */
dc877563	139	NULL, /* class_finalize */
	140	NULL, /* class_data */
	141	sizeof (LttvTracesetContext),
	142	0, /* n_preallocs */
ffd54a90	143	(GInstanceInitFunc) traceset_state_instance_init /* instance_init */
dc877563	144	};
	145
	146	type = g_type_register_static (LTTV_TRACESET_CONTEXT_TYPE, "LttvTracesetStateType",
	147	&info, 0);
	148	}
	149	return type;
	150	}
	151
	152
	153	static void
ffd54a90	154	trace_state_instance_init (GTypeInstance *instance, gpointer g_class)
dc877563	155	{
	156	}
	157
	158
	159	static void
ffd54a90	160	trace_state_finalize (LttvTraceContext *self)
dc877563	161	{
ffd54a90	162	G_OBJECT_CLASS(g_type_class_peek_parent(LTTV_TRACE_STATE_GET_CLASS(self)))->finalize(G_OBJECT(self));
dc877563	163	}
	164
	165
	166	static void
ffd54a90	167	trace_state_class_init (LttvTraceContextClass *klass)
dc877563	168	{
	169	GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
	170
ffd54a90	171	gobject_class->finalize = (void ()(GObject self)) trace_state_finalize;
dc877563	172	}
	173
	174
	175	GType
	176	lttv_trace_state_get_type(void)
	177	{
	178	static GType type = 0;
	179	if (type == 0) {
	180	static const GTypeInfo info = {
	181	sizeof (LttvTraceStateClass),
	182	NULL, /* base_init */
	183	NULL, /* base_finalize */
ffd54a90	184	(GClassInitFunc) trace_state_class_init, /* class_init */
dc877563	185	NULL, /* class_finalize */
	186	NULL, /* class_data */
	187	sizeof (LttvTracesetState),
	188	0, /* n_preallocs */
ffd54a90	189	(GInstanceInitFunc) trace_state_instance_init /* instance_init */
dc877563	190	};
	191
	192	type = g_type_register_static (LTTV_TRACE_CONTEXT_TYPE,
	193	"LttvTraceStateType", &info, 0);
	194	}
	195	return type;
	196	}
	197
	198
	199	static void
ffd54a90	200	tracefile_state_instance_init (GTypeInstance *instance, gpointer g_class)
dc877563	201	{
	202	}
	203
	204
	205	static void
ffd54a90	206	tracefile_state_finalize (LttvTracefileState *self)
dc877563	207	{
ffd54a90	208	G_OBJECT_CLASS(g_type_class_peek_parent(LTTV_TRACEFILE_STATE_GET_CLASS(self)))->finalize(G_OBJECT(self));
dc877563	209	}
	210
	211
	212	static void
ffd54a90	213	tracefile_state_class_init (LttvTracefileStateClass *klass)
dc877563	214	{
	215	GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
	216
ffd54a90	217	gobject_class->finalize = (void ()(GObject self)) tracefile_state_finalize;
dc877563	218	}
	219
	220
	221	GType
	222	lttv_tracefile_state_get_type(void)
	223	{
	224	static GType type = 0;
	225	if (type == 0) {
	226	static const GTypeInfo info = {
	227	sizeof (LttvTracefileStateClass),
	228	NULL, /* base_init */
	229	NULL, /* base_finalize */
ffd54a90	230	(GClassInitFunc) tracefile_state_class_init, /* class_init */
dc877563	231	NULL, /* class_finalize */
	232	NULL, /* class_data */
	233	sizeof (LttvTracefileState),
	234	0, /* n_preallocs */
ffd54a90	235	(GInstanceInitFunc) tracefile_state_instance_init /* instance_init */
dc877563	236	};
	237
	238	type = g_type_register_static (LTTV_TRACEFILE_CONTEXT_TYPE,
	239	"LttvTracefileStateType", &info, 0);
	240	}
	241	return type;
	242	}
	243
	244
dc877563	245	struct HookData {
	246	LttField *f1;
	247	LttField *f2;
	248	LttField *f3;
ffd54a90	249	};
dc877563	250
	251
	252	struct HookId {
	253	LttvHook h;
	254	guint id;
	255	void *hook_data;
	256	gboolean free_hook_data;
ffd54a90	257	};
dc877563	258
dc877563	259
ffd54a90	260	static void push_state(LttvTracefileState *tfs, LttvInterruptType t,
ffd54a90	261	guint state_id)
dc877563	262	{
ffd54a90	263	LttvInterruptState *intr;
dc877563	264
	265	LttvProcessState *process = tfs->process;
	266
	267	guint depth = process->interrupt_stack->len;
	268
	269	g_array_set_size(process->interrupt_stack, depth + 1);
	270	intr = &g_array_index(process->interrupt_stack, LttvInterruptState, depth);
	271	intr->t = t;
	272	intr->n = state_id;
ffd54a90	273	intr->entry = intr->last_change = LTTV_TRACEFILE_CONTEXT(tfs)->timestamp;
dc877563	274	intr->s = process->state->s;
	275	}
	276
	277
ffd54a90	278	static void pop_state(LttvTracefileState *tfs, LttvInterruptType t)
dc877563	279	{
	280	LttvProcessState *process = tfs->process;
	281
	282	guint depth = process->interrupt_stack->len - 1;
	283
	284	g_assert(process->state->t == t);
	285	g_array_remove_index(process->interrupt_stack, depth);
	286	depth--;
	287	process->state = &g_array_index(process->interrupt_stack, LttvInterruptState,
	288	depth);
	289	}
	290
	291
ffd54a90	292	LttvProcessState create_process(LttvTracefileState tfs,
ffd54a90	293	LttvProcessState *parent, guint pid)
dc877563	294	{
	295	LttvProcessState *process = g_new(LttvProcessState, 1);
	296
	297	LttvInterruptState *intr;
	298
ffd54a90	299	LttvTraceContext *tc;
ffd54a90	300
ba576a78	301	LttvTraceState *tcs;
	302
	303	LttvTracefileContext *tfc = LTTV_TRACEFILE_CONTEXT(tfs);
ffd54a90	304
ba576a78	305	tcs = (LttvTraceState *)tc = tfc->t_context;
ffd54a90	306
ffd54a90	307	g_hash_table_insert(tcs->processes, GUINT_TO_POINTER(pid), process);
dc877563	308	process->pid = pid;
ba576a78	309	process->birth = tfc->timestamp;
dc877563	310	process->name = LTTV_STATE_UNNAMED;
	311	process->interrupt_stack = g_array_new(FALSE, FALSE,
	312	sizeof(LttvInterruptState));
	313	g_array_set_size(process->interrupt_stack, 1);
ffd54a90	314	intr = process->state = &g_array_index(process->interrupt_stack,
ffd54a90	315	LttvInterruptState, 0);
ba576a78	316	intr->t = LTTV_STATE_USER_MODE;
dc877563	317	intr->n = 0;
ba576a78	318	intr->entry = tfc->timestamp;
ba576a78	319	intr->last_change = tfc->timestamp;
dc877563	320	intr->s = LTTV_STATE_WAIT_FORK;
	321	}
	322
	323
ba576a78	324	LttvProcessState find_process(LttvTracefileState tfs, guint pid)
dc877563	325	{
ba576a78	326	LttvTraceState ts =(LttvTraceState )LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
	327	LttvProcessState *process = g_hash_table_lookup(ts->processes,
	328	GUINT_TO_POINTER(pid));
dc877563	329	if(process == NULL) process = create_process(tfs, NULL, pid);
	330	return process;
	331	}
	332
	333
ba576a78	334	void exit_process(LttvTracefileState tfs, LttvProcessState process)
dc877563	335	{
ba576a78	336	LttvTraceState *ts = LTTV_TRACE_STATE(tfs->parent.t_context);
	337
	338	g_hash_table_remove(ts->processes, GUINT_TO_POINTER(process->pid));
dc877563	339	g_array_free(process->interrupt_stack, TRUE);
	340	g_free(process);
	341	}
	342
	343
	344	void free_process_state(gpointer key, gpointer value, gpointer user_data)
	345	{
	346	g_array_free(((LttvProcessState *)value)->interrupt_stack, TRUE);
	347	g_free(value);
	348	}
	349
	350
	351	void remove_all_processes(GHashTable *processes)
	352	{
	353	g_hash_table_foreach(processes, free_process_state, NULL);
	354	}
	355
	356
	357	gboolean syscall_entry(void hook_data, void call_data)
	358	{
	359	LttField f = (LttField )hook_data;
	360
ba576a78	361	LttvTracefileState s = (LttvTracefileState )call_data;
dc877563	362
ba576a78	363	push_state(s, LTTV_STATE_SYSCALL, ltt_event_get_unsigned(
ba576a78	364	LTTV_TRACEFILE_CONTEXT(s)->e, f));
dc877563	365	return FALSE;
	366	}
	367
	368
	369	gboolean syscall_exit(void hook_data, void call_data)
	370	{
ba576a78	371	LttvTracefileState s = (LttvTracefileState )call_data;
dc877563	372
ffd54a90	373	pop_state(s, LTTV_STATE_SYSCALL);
dc877563	374	return FALSE;
	375	}
	376
	377
	378	gboolean trap_entry(void hook_data, void call_data)
	379	{
	380	LttField f = (LttField )hook_data;
	381
ba576a78	382	LttvTracefileState s = (LttvTracefileState )call_data;
dc877563	383
ba576a78	384	push_state(s, LTTV_STATE_TRAP, ltt_event_get_unsigned(s->parent.e, f));
dc877563	385	return FALSE;
	386	}
	387
	388
	389	gboolean trap_exit(void hook_data, void call_data)
	390	{
ba576a78	391	LttvTracefileState s = (LttvTracefileState )call_data;
dc877563	392
ffd54a90	393	pop_state(s, LTTV_STATE_TRAP);
dc877563	394	return FALSE;
	395	}
	396
	397
	398	gboolean irq_entry(void hook_data, void call_data)
	399	{
	400	LttField f = (LttField )hook_data;
	401
ba576a78	402	LttvTracefileState s = (LttvTracefileState )call_data;
dc877563	403
dc877563	404	/* Do something with the info about being in user or system mode when int? */
ba576a78	405	push_state(s, LTTV_STATE_IRQ, ltt_event_get_unsigned(s->parent.e, f));
dc877563	406	return FALSE;
	407	}
	408
	409
	410	gboolean irq_exit(void hook_data, void call_data)
	411	{
ba576a78	412	LttvTracefileState s = (LttvTracefileState )call_data;
dc877563	413
ffd54a90	414	pop_state(s, LTTV_STATE_IRQ);
dc877563	415	return FALSE;
	416	}
	417
	418
	419	gboolean schedchange(void hook_data, void call_data)
	420	{
	421	struct HookData h = (struct HookData )hook_data;
	422
ba576a78	423	LttvTracefileState s = (LttvTracefileState )call_data;
dc877563	424
	425	guint pid_in, pid_out, state_out;
	426
ba576a78	427	pid_in = ltt_event_get_int(s->parent.e, h->f1);
	428	pid_out = ltt_event_get_int(s->parent.e, h->f2);
	429	state_out = ltt_event_get_int(s->parent.e, h->f3);
dc877563	430	if(s->process != NULL) {
ffd54a90	431	if(state_out == 0) s->process->state->s = LTTV_STATE_WAIT_CPU;
ffd54a90	432	else if(s->process->state->s == LTTV_STATE_EXIT)
ba576a78	433	exit_process(s, s->process);
ffd54a90	434	else s->process->state->s = LTTV_STATE_WAIT;
dc877563	435	}
ba576a78	436	s->process = find_process(s, pid_in);
ffd54a90	437	s->process->state->s = LTTV_STATE_RUN;
dc877563	438	return FALSE;
	439	}
	440
	441
	442	gboolean process_fork(void hook_data, void call_data)
	443	{
	444	LttField f = (LttField )hook_data;
	445
ba576a78	446	LttvTracefileState s = (LttvTracefileState )call_data;
dc877563	447
	448	guint child_pid;
	449
ba576a78	450	child_pid = ltt_event_get_int(s->parent.e, f);
ba576a78	451	create_process(s, s->process, child_pid);
dc877563	452	return FALSE;
	453	}
	454
	455
	456	gboolean process_exit(void hook_data, void call_data)
	457	{
ba576a78	458	LttvTracefileState s = (LttvTracefileState )call_data;
dc877563	459
dc877563	460	if(s->process != NULL) {
ffd54a90	461	s->process->state->s = LTTV_STATE_EXIT;
dc877563	462	}
	463	return FALSE;
	464	}
	465
	466
	467	static LttField *
	468	find_field(LttEventType et, const char field)
	469	{
	470	LttType *t;
	471
	472	LttField *f;
	473
	474	guint i, nb;
	475
	476	char *name;
	477
	478	if(field == NULL) return NULL;
	479
	480	f = ltt_eventtype_field(et);
	481	t = ltt_eventtype_type(et);
	482	g_assert(ltt_type_class(t) == LTT_STRUCT);
	483	nb = ltt_type_member_number(t);
	484	for(i = 0 ; i < nb ; i++) {
	485	ltt_type_member_type(t, i, &name);
	486	if(strcmp(name, field) == 0) break;
	487	}
	488	g_assert(i < nb);
	489	return ltt_field_member(f, i);
	490	}
	491
	492
ba576a78	493	static struct HookId
	494	find_hook(LttTrace t, char facility, char *event,
	495	char field1, char field2, char *field3, LttvHook h)
dc877563	496	{
	497	LttFacility *f;
	498
	499	LttEventType *et;
	500
	501	guint nb, pos, i;
	502
	503	struct HookId hook_id;
	504
	505	struct HookData hook_data, *phook_data;
	506
	507	char *name;
	508
	509	nb = ltt_trace_facility_find(t, facility, &pos);
	510	if(nb < 1) g_error("No %s facility", facility);
ba576a78	511	f = ltt_trace_facility_get(t, pos);
ba576a78	512	et = ltt_facility_eventtype_get_by_name(f, event);
dc877563	513	if(et == NULL) g_error("Event %s does not exist", event);
dc877563	514
ba576a78	515	hook_id.id = (ltt_eventtype_id(et)); / CHECK */
dc877563	516	hook_id.h = h;
	517	hook_id.free_hook_data = FALSE;
	518	hook_data.f1 = find_field(et, field1);
	519	hook_data.f2 = find_field(et, field2);
	520	hook_data.f3 = find_field(et, field3);
ba576a78	521	if(hook_data.f1 == NULL) hook_id.hook_data = NULL;
ba576a78	522	else if(hook_data.f2 == NULL) hook_id.hook_data = hook_data.f1;
dc877563	523	else {
	524	phook_data = g_new(struct HookData, 1);
	525	*phook_data = hook_data;
	526	hook_id.hook_data = phook_data;
	527	hook_id.free_hook_data = TRUE;
	528	}
	529	return hook_id;
	530	}
	531
	532
	533	lttv_state_add_event_hooks(LttvTracesetState *self)
	534	{
ba576a78	535	LttvTraceset *traceset = self->parent.ts;
dc877563	536
ba576a78	537	guint i, j, k, nb_trace, nb_control, nb_per_cpu, nb_tracefile;
dc877563	538
	539	LttFacility *f;
	540
	541	LttEventType *et;
	542
ba576a78	543	LttvTraceState *ts;
dc877563	544
ba576a78	545	LttvTracefileState *tfs;
dc877563	546
	547	void *hook_data;
	548
	549	GArray *hooks;
	550
	551	struct HookId hook_id;
	552
	553	LttvAttributeValue val;
	554
ba576a78	555	nb_trace = lttv_traceset_number(traceset);
dc877563	556	for(i = 0 ; i < nb_trace ; i++) {
ba576a78	557	ts = (LttvTraceState *)self->parent.traces[i];
dc877563	558
	559	/* Find the eventtype id for the following events and register the
	560	associated by id hooks. */
	561
ba576a78	562	hooks = g_array_new(FALSE, FALSE, sizeof(struct HookId));
	563	g_array_add(hooks, find_hook(ts->parent.t, "core","syscall_entry",
	564	"syscall_id", NULL, NULL, syscall_entry));
	565	g_array_add(hooks, find_hook(ts->parent.t, "core", "syscall_exit",
	566	NULL, NULL, NULL, syscall_exit));
	567	g_array_add(hooks, find_hook(ts->parent.t, "core", "trap_entry", "trap_id",
	568	NULL, NULL, trap_entry));
	569	g_array_add(hooks, find_hook(ts->parent.t, "core", "trap_exit", NULL, NULL,
dc877563	570	NULL, trap_exit));
ba576a78	571	g_array_add(hooks, find_hook(ts->parent.t, "core", "irq_entry", "irq_id",
	572	NULL, NULL, irq_entry));
	573	g_array_add(hooks, find_hook(ts->parent.t, "core", "irq_exit", NULL, NULL,
dc877563	574	NULL, irq_exit));
ba576a78	575	g_array_add(hooks, find_hook(ts->parent.t, "core", "schedchange",
	576	"in", "out", "out_state", schedchange));
	577	g_array_add(hooks, find_hook(ts->parent.t, "core", "process_fork",
	578	"child_pid", NULL, NULL, process_fork));
	579	g_array_add(hooks, find_hook(ts->parent.t, "core", "process_exit",
	580	NULL, NULL, NULL, process_exit));
dc877563	581
	582	/* Add these hooks to each before_event_by_id hooks list */
	583
ba576a78	584	nb_control = ltt_trace_control_tracefile_number(ts->parent.t);
ba576a78	585	nb_per_cpu = ltt_trace_control_tracefile_number(ts->parent.t);
dc877563	586	nb_tracefile = nb_control + nb_per_cpu;
	587	for(j = 0 ; j < nb_tracefile ; j++) {
	588	if(j < nb_control) {
ba576a78	589	tfs = LTTV_TRACEFILE_STATE(ts->parent.control_tracefiles[j]);
dc877563	590	}
dc877563	591	else {
ba576a78	592	tfs = LTTV_TRACEFILE_STATE(ts->parent.per_cpu_tracefiles[j]);
dc877563	593	}
	594
	595	for(k = 0 ; k < hooks->len ; k++) {
	596	hook_id = g_array_index(hooks, struct HookId, k);
ba576a78	597	lttv_hooks_add(lttv_hooks_by_id_find(tfs->parent.before_event_by_id,
ba576a78	598	hook_id.id), hook_id.h, hook_id.hook_data);
ffd54a90	599	}
dc877563	600	}
ba576a78	601	lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
ba576a78	602	*(val.v_pointer) = hooks;
dc877563	603	}
	604	}
	605
	606
	607	lttv_state_remove_event_hooks(LttvTracesetState *self)
	608	{
ba576a78	609	LttvTraceset *traceset = self->parent.ts;
dc877563	610
ba576a78	611	guint i, j, k, nb_trace, nb_control, nb_per_cpu, nb_tracefile;
dc877563	612
ba576a78	613	LttvTraceState *ts;
dc877563	614
ba576a78	615	LttvTracefileState *tfs;
dc877563	616
	617	void *hook_data;
	618
	619	GArray *hooks;
	620
	621	struct HookId hook_id;
	622
	623	LttvAttributeValue val;
	624
ba576a78	625	nb_trace = lttv_traceset_number(traceset);
dc877563	626	for(i = 0 ; i < nb_trace ; i++) {
ba576a78	627	ts = LTTV_TRACE_STATE(self->parent.traces[i]);
	628	lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
	629	hooks = *(val.v_pointer);
dc877563	630
	631	/* Add these hooks to each before_event_by_id hooks list */
	632
ba576a78	633	nb_control = ltt_trace_control_tracefile_number(ts->parent.t);
ba576a78	634	nb_per_cpu = ltt_trace_control_tracefile_number(ts->parent.t);
dc877563	635	nb_tracefile = nb_control + nb_per_cpu;
	636	for(j = 0 ; j < nb_tracefile ; j++) {
	637	if(j < nb_control) {
ba576a78	638	tfs = LTTV_TRACEFILE_STATE(ts->parent.control_tracefiles[j]);
dc877563	639	}
dc877563	640	else {
ba576a78	641	tfs = LTTV_TRACEFILE_STATE(ts->parent.per_cpu_tracefiles[j]);
dc877563	642	}
	643
	644	for(k = 0 ; k < hooks->len ; k++) {
	645	hook_id = g_array_index(hooks, struct HookId, k);
ba576a78	646	lttv_hooks_remove_data(
	647	lttv_hooks_by_id_find(tfs->parent.before_event_by_id,
	648	hook_id.id), hook_id.h, hook_id.hook_data);
ffd54a90	649
	650	}
	651	for(k = 0 ; k < hooks->len ; k++) {
	652	hook_id = g_array_index(hooks, struct HookId, k);
ba576a78	653	if(hook_id.free_hook_data) g_free(hook_id.hook_data);
ffd54a90	654	}
dc877563	655	}
	656	g_array_free(hooks, TRUE);
	657	}
	658	}
	659
	660
ffd54a90	661	void lttv_state_init(int argc, char **argv)
	662	{
	663	LTTV_STATE_UNNAMED = g_quark_from_string("unnamed");
	664	LTTV_STATE_USER_MODE = g_quark_from_string("user mode");
	665	LTTV_STATE_WAIT_FORK = g_quark_from_string("wait fork");
	666	LTTV_STATE_SYSCALL = g_quark_from_string("system call");
	667	LTTV_STATE_TRAP = g_quark_from_string("trap");
	668	LTTV_STATE_IRQ = g_quark_from_string("irq");
	669	LTTV_STATE_WAIT_CPU = g_quark_from_string("wait for cpu");
	670	LTTV_STATE_EXIT = g_quark_from_string("exiting");
	671	LTTV_STATE_WAIT = g_quark_from_string("wait for I/O");
	672	LTTV_STATE_RUN = g_quark_from_string("running");
	673	LTTV_STATE_HOOKS = g_quark_from_string("saved state hooks");
	674	}
dc877563	675
ffd54a90	676	void lttv_state_destroy()
	677	{
	678	}
dc877563	679
	680
	681
	682