X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Fstate.c;h=0a058c62dae633d29a943bd0b4721ddd6c494e4f;hb=0c0168a8f2530b37c6b63a340835f8141adbed27;hp=4ef1e6419cabad04caf6b9fc334e911a728a1605;hpb=5e563da0170db1c625eed273e553320ce18edbe5;p=lttv.git

diff --git a/ltt/branches/poly/lttv/lttv/state.c b/ltt/branches/poly/lttv/lttv/state.c
index 4ef1e641..0a058c62 100644
--- a/ltt/branches/poly/lttv/lttv/state.c
+++ b/ltt/branches/poly/lttv/lttv/state.c
@@ -49,7 +49,8 @@ GQuark
     LTT_FACILITY_KERNEL_ARCH,
     LTT_FACILITY_LIST,
     LTT_FACILITY_FS,
-    LTT_FACILITY_USER_GENERIC;
+    LTT_FACILITY_USER_GENERIC,
+    LTT_FACILITY_BLOCK;
 
 /* Events Quarks */
 
@@ -72,7 +73,9 @@ GQuark
     LTT_EVENT_STATEDUMP_END,
     LTT_EVENT_FUNCTION_ENTRY,
     LTT_EVENT_FUNCTION_EXIT,
-    LTT_EVENT_THREAD_BRAND;
+    LTT_EVENT_THREAD_BRAND,
+    LTT_EVENT_REQUEST_ISSUE,
+    LTT_EVENT_REQUEST_COMPLETE;
 
 /* Fields Quarks */
 
@@ -96,7 +99,10 @@ GQuark
     LTT_FIELD_SUBMODE,
     LTT_FIELD_STATUS,
     LTT_FIELD_THIS_FN,
-    LTT_FIELD_CALL_SITE;
+    LTT_FIELD_CALL_SITE,
+    LTT_FIELD_MINOR,
+    LTT_FIELD_MAJOR,
+    LTT_FIELD_OPERATION;
 
 LttvExecutionMode
   LTTV_STATE_MODE_UNKNOWN,
@@ -139,6 +145,12 @@ LttvIRQMode
   LTTV_IRQ_IDLE,
   LTTV_IRQ_BUSY;
 
+LttvBdevMode
+  LTTV_BDEV_UNKNOWN,
+  LTTV_BDEV_IDLE,
+  LTTV_BDEV_BUSY_READING,
+  LTTV_BDEV_BUSY_WRITING;
+
 static GQuark
   LTTV_STATE_TRACEFILES,
   LTTV_STATE_PROCESSES,
@@ -150,7 +162,9 @@ static GQuark
   LTTV_STATE_TIME,
   LTTV_STATE_HOOKS,
   LTTV_STATE_NAME_TABLES,
-  LTTV_STATE_TRACE_STATE_USE_COUNT;
+  LTTV_STATE_TRACE_STATE_USE_COUNT,
+  LTTV_STATE_RESOURCE_CPUS,
+  LTTV_STATE_RESOURCE_IRQS;
 
 static void create_max_time(LttvTraceState *tcs);
 
@@ -230,7 +244,7 @@ static void lttv_state_free_usertraces(GHashTable *usertraces)
 static void
 restore_init_state(LttvTraceState *self)
 {
-  guint i, nb_cpus;
+  guint i, nb_cpus, nb_irqs;
 
   LttvTracefileState *tfcs;
 
@@ -255,6 +269,7 @@ restore_init_state(LttvTraceState *self)
   //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++) {
@@ -273,6 +288,15 @@ restore_init_state(LttvTraceState *self)
 
     //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);
+  }
+
+  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);
   }
   
 #if 0
@@ -439,6 +463,9 @@ init(LttvTracesetState *self, LttvTraceset *ts)
       g_assert(tcs->irq_states[j].mode_stack != NULL);
     } 
 
+    /* init bdev resource stuff */
+    tcs->bdev_states = g_hash_table_new(g_int_hash, g_int_equal);
+
     restore_init_state(tcs);
     for(j = 0 ; j < nb_tracefile ; j++) {
       tfcs = 
@@ -1087,6 +1114,64 @@ static GHashTable *lttv_state_copy_process_table(GHashTable *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, FALSE);
+  }
+
+  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);
+}
 
 /* The saved state for each trace contains a member "processes", which
    stores a copy of the process table, and a member "tracefiles" with
@@ -1096,7 +1181,7 @@ static GHashTable *lttv_state_copy_process_table(GHashTable *processes)
 
 static void state_save(LttvTraceState *self, LttvAttribute *container)
 {
-  guint i, nb_tracefile, nb_cpus;
+  guint i, nb_tracefile, nb_cpus, nb_irqs;
 
   LttvTracefileState *tfcs;
 
@@ -1168,12 +1253,29 @@ static void state_save(LttvTraceState *self, LttvAttribute *container)
           tfcs->parent.timestamp.tv_sec, tfcs->parent.timestamp.tv_nsec);
     }
   }
+
+  /* save the cpu state */
+  {
+    guint size = sizeof(LttvCPUState)*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;
+  {
+    guint size = sizeof(LttvCPUState)*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);
+  }
 }
 
 
 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;
 
@@ -1214,11 +1316,23 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container)
     g_assert(self->running_process[i] != NULL);
   }
 
- 
   nb_tracefile = self->parent.tracefiles->len;
 
   //g_tree_destroy(tsc->pqueue);
   //tsc->pqueue = g_tree_new(compare_tracefile);
+
+  /* restore cpu resource states */
+  type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_CPUS, &value);
+  g_assert(type == LTTV_POINTER);
+  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);
  
   for(i = 0 ; i < nb_tracefile ; i++) {
     tfcs = 
@@ -1240,6 +1354,8 @@ static void state_restore(LttvTraceState *self, LttvAttribute *container)
     //g_assert(*(value.v_pointer) != NULL);
     ep = *(value.v_pointer);
     g_assert(tfcs->parent.t_context != NULL);
+
+    tfcs->cpu_state = &self->cpu_states[tfcs->cpu];
     
     LttvTracefileContext *tfc = LTTV_TRACEFILE_CONTEXT(tfcs);
     g_tree_remove(tsc->pqueue, tfc);
@@ -1620,13 +1736,33 @@ static void cpu_push_mode(LttvCPUState *cpust, LttvCPUMode state)
 
 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);
 }
 
 /* clears the stack and sets the state passed as argument */
+static void bdev_set_base_mode(LttvBdevState *bdevst, LttvBdevMode state)
+{
+  g_array_set_size(bdevst->mode_stack, 1);
+  ((GQuark *)bdevst->mode_stack->data)[0] = state;
+}
+
+static void bdev_push_mode(LttvBdevState *bdevst, LttvBdevMode state)
+{
+  g_array_set_size(bdevst->mode_stack, bdevst->mode_stack->len + 1);
+  ((GQuark *)bdevst->mode_stack->data)[bdevst->mode_stack->len - 1] = state;
+}
+
+static void bdev_pop_mode(LttvBdevState *bdevst)
+{
+  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_set_base_mode(LttvIRQState *irqst, LttvIRQMode state)
 {
   g_array_set_size(irqst->mode_stack, 1);
@@ -1641,7 +1777,7 @@ static void irq_push_mode(LttvIRQState *irqst, LttvIRQMode state)
 
 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);
@@ -2059,6 +2195,7 @@ static gboolean irq_entry(void *hook_data, void *call_data)
   cpu_push_mode(s->cpu_state, LTTV_CPU_IRQ);
 
   /* update irq status */
+  s->cpu_state->last_irq = irq;
   irq_push_mode(&ts->irq_states[irq], LTTV_IRQ_BUSY);
 
   return FALSE;
@@ -2077,12 +2214,16 @@ static gboolean soft_irq_exit(void *hook_data, void *call_data)
 static gboolean irq_exit(void *hook_data, void *call_data)
 {
   LttvTracefileState *s = (LttvTracefileState *)call_data;
+  LttvTraceState *ts = (LttvTraceState *)s->parent.t_context;
 
   pop_state(s, LTTV_STATE_IRQ);
 
   /* update cpu status */
   cpu_pop_mode(s->cpu_state);
 
+  /* update irq status */
+  irq_pop_mode(&ts->irq_states[s->cpu_state->last_irq]);
+
   return FALSE;
 }
 
@@ -2118,6 +2259,71 @@ static gboolean soft_irq_entry(void *hook_data, void *call_data)
   return FALSE;
 }
 
+LttvBdevState *bdev_state_get(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);
+    printf("adding key %u to hash table\n", *key);
+
+    bdev = bdevstate;
+  }
+
+  return bdev;
+}
+
+static gboolean bdev_request_issue(void *hook_data, void *call_data)
+{
+  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;
+
+  guint major = ltt_event_get_long_unsigned(e, thf->f1);
+  guint minor = ltt_event_get_long_unsigned(e, thf->f2);
+  guint oper = ltt_event_get_long_unsigned(e, thf->f3);
+  guint16 devcode = MKDEV(major,minor);
+
+  /* have we seen this block device before? */
+  gpointer bdev = bdev_state_get(ts, devcode);
+
+  if(oper == 0)
+    bdev_push_mode(bdev, LTTV_BDEV_BUSY_READING);
+  else
+    bdev_push_mode(bdev, LTTV_BDEV_BUSY_WRITING);
+
+  return FALSE;
+}
+
+static gboolean bdev_request_complete(void *hook_data, void *call_data)
+{
+  LttvTracefileState *s = (LttvTracefileState *)call_data;
+  LttvTraceState *ts = (LttvTraceState *)s->parent.t_context;
+  LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+  LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
+
+  guint major = ltt_event_get_long_unsigned(e, thf->f1);
+  guint minor = ltt_event_get_long_unsigned(e, thf->f2);
+  guint oper = ltt_event_get_long_unsigned(e, thf->f3);
+  guint16 devcode = MKDEV(major,minor);
+
+  /* have we seen this block device before? */
+  gpointer bdev = bdev_state_get(ts, devcode);
+
+  /* update block device */
+  bdev_pop_mode(bdev);
+
+  return FALSE;
+}
+
 static void push_function(LttvTracefileState *tfs, guint64 funcptr)
 {
   guint64 *new_func;
@@ -2877,6 +3083,18 @@ void lttv_state_add_event_hooks(LttvTracesetState *self)
         statedump_end, 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,
+        bdev_request_issue, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+    if(ret) hn--;
+
+    ret = lttv_trace_find_hook(ts->parent.t,
+        LTT_FACILITY_BLOCK, LTT_EVENT_REQUEST_COMPLETE,
+        LTT_FIELD_MAJOR, LTT_FIELD_MINOR, LTT_FIELD_OPERATION,
+        bdev_request_complete, NULL, &g_array_index(hooks, LttvTraceHook, hn++));
+    if(ret) hn--;
+
     ret = lttv_trace_find_hook(ts->parent.t,
         LTT_FACILITY_USER_GENERIC, LTT_EVENT_FUNCTION_ENTRY,
         LTT_FIELD_THIS_FN, LTT_FIELD_CALL_SITE, 0,
@@ -3558,6 +3776,7 @@ static void module_init()
   LTTV_STATE_NAME_TABLES = g_quark_from_string("name tables");
   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");
 
   
   LTT_FACILITY_KERNEL     = g_quark_from_string("kernel");
@@ -3565,6 +3784,7 @@ static void module_init()
   LTT_FACILITY_FS    = g_quark_from_string("fs");
   LTT_FACILITY_LIST = g_quark_from_string("list");
   LTT_FACILITY_USER_GENERIC    = g_quark_from_string("user_generic");
+  LTT_FACILITY_BLOCK = g_quark_from_string("block");
 
   
   LTT_EVENT_SYSCALL_ENTRY = g_quark_from_string("syscall_entry");
@@ -3586,6 +3806,8 @@ static void module_init()
   LTT_EVENT_FUNCTION_ENTRY  = g_quark_from_string("function_entry");
   LTT_EVENT_FUNCTION_EXIT  = g_quark_from_string("function_exit");
   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_FIELD_SYSCALL_ID    = g_quark_from_string("syscall_id");
@@ -3608,6 +3830,9 @@ static void module_init()
   LTT_FIELD_STATUS        = g_quark_from_string("status");
   LTT_FIELD_THIS_FN       = g_quark_from_string("this_fn");
   LTT_FIELD_CALL_SITE     = g_quark_from_string("call_site");
+  LTT_FIELD_MAJOR     = g_quark_from_string("major");
+  LTT_FIELD_MINOR     = g_quark_from_string("minor");
+  LTT_FIELD_OPERATION     = g_quark_from_string("direction");
   
   LTTV_CPU_UNKNOWN = g_quark_from_string("unknown");
   LTTV_CPU_IDLE = g_quark_from_string("idle");
@@ -3618,6 +3843,11 @@ static void module_init()
   LTTV_IRQ_UNKNOWN = g_quark_from_string("unknown");
   LTTV_IRQ_IDLE = g_quark_from_string("idle");
   LTTV_IRQ_BUSY = g_quark_from_string("busy");
+
+  LTTV_BDEV_UNKNOWN = g_quark_from_string("unknown");
+  LTTV_BDEV_IDLE = g_quark_from_string("idle");
+  LTTV_BDEV_BUSY_READING = g_quark_from_string("busy_reading");
+  LTTV_BDEV_BUSY_WRITING = g_quark_from_string("busy_writing");
 }
 
 static void module_destroy()