LTT_FIELD_ADDRESS,
LTT_FIELD_SYMBOL,
LTT_FIELD_IP,
- LTT_FIELD_FD;
+ LTT_FIELD_FD,
+ LTT_FIELD_STATE,
+ LTT_FIELD_CPU_ID;
LttvExecutionMode
LTTV_STATE_MODE_UNKNOWN,
static LttvBdevState *bdevstate_copy(LttvBdevState *bds);
-#if (__SIZEOF_LONG__ == 4)
+#if (__WORDSIZE == 32)
guint guint64_hash(gconstpointer key)
{
guint64 ukey = *(const guint64 *)key;
GQuark *old_table = *table;
*table = g_new(GQuark, new_nb);
memcpy(*table, old_table, nb * sizeof(GQuark));
+ g_free(old_table);
}
static void fill_name_table(LttvTraceState *ts, GQuark *table, guint nb,
static void expand_syscall_table(LttvTraceState *ts, int id)
{
- guint new_nb = check_expand(ts->nb_syscalls, id);
- if(likely(new_nb == ts->nb_syscalls))
+ LttvNameTables *nt = ts->name_tables;
+ guint new_nb;
+
+ new_nb = check_expand(nt->nb_syscalls, id);
+ if(likely(new_nb == nt->nb_syscalls))
return;
- expand_name_table(ts, &ts->syscall_names, ts->nb_syscalls, new_nb);
- fill_name_table(ts, ts->syscall_names, ts->nb_syscalls, new_nb, "syscall");
+ expand_name_table(ts, &nt->syscall_names, nt->nb_syscalls, new_nb);
+ fill_name_table(ts, nt->syscall_names, nt->nb_syscalls, new_nb, "syscall");
/* Update the table size */
- ts->nb_syscalls = new_nb;
+ nt->nb_syscalls = new_nb;
}
static void expand_kprobe_table(LttvTraceState *ts, guint64 ip, char *symbol)
{
-#if (__SIZEOF_LONG__ == 4)
+ LttvNameTables *nt = ts->name_tables;
+#if (__WORDSIZE == 32)
guint64 *ip_ptr = g_new(guint64, 1);
- g_hash_table_insert(ts->kprobe_hash, ip_ptr,
+ g_hash_table_insert(nt->kprobe_hash, ip_ptr,
(gpointer)(glong)g_quark_from_string(symbol));
#else
- g_hash_table_insert(ts->kprobe_hash, (gpointer)ip,
+ g_hash_table_insert(nt->kprobe_hash, (gpointer)ip,
(gpointer)(glong)g_quark_from_string(symbol));
#endif
}
static void expand_trap_table(LttvTraceState *ts, int id)
{
- guint new_nb = check_expand(ts->nb_traps, id);
- guint i;
- if(likely(new_nb == ts->nb_traps))
+ LttvNameTables *nt = ts->name_tables;
+ LttvTrapState *old_table;
+ guint new_nb, i;
+
+ new_nb = check_expand(nt->nb_traps, id);
+ if(likely(new_nb == nt->nb_traps))
return;
- expand_name_table(ts, &ts->trap_names, ts->nb_traps, new_nb);
- fill_name_table(ts, ts->trap_names, ts->nb_traps, new_nb, "trap");
- /* Update the table size */
- ts->nb_traps = new_nb;
- LttvTrapState *old_table = ts->trap_states;
+ expand_name_table(ts, &nt->trap_names, nt->nb_traps, new_nb);
+ fill_name_table(ts, nt->trap_names, nt->nb_traps, new_nb, "trap");
+
+ old_table = ts->trap_states;
ts->trap_states = g_new(LttvTrapState, new_nb);
- memcpy(ts->trap_states, old_table,
- ts->nb_traps * sizeof(LttvTrapState));
- for(i = ts->nb_traps; i < new_nb; i++)
+ memcpy(ts->trap_states, old_table, nt->nb_traps * sizeof(LttvTrapState));
+ g_free(old_table);
+ for(i = nt->nb_traps; i < new_nb; i++)
ts->trap_states[i].running = 0;
+
+ /* Update the table size */
+ nt->nb_traps = new_nb;
}
static void expand_irq_table(LttvTraceState *ts, int id)
{
- guint new_nb = check_expand(ts->nb_irqs, id);
- guint i;
- if(likely(new_nb == ts->nb_irqs))
+ LttvNameTables *nt = ts->name_tables;
+ LttvIRQState *old_table;
+ guint new_nb, i;
+
+ new_nb = check_expand(nt->nb_irqs, id);
+ if(likely(new_nb == nt->nb_irqs))
return;
- expand_name_table(ts, &ts->irq_names, ts->nb_irqs, new_nb);
- fill_name_table(ts, ts->irq_names, ts->nb_irqs, new_nb, "irq");
- LttvIRQState *old_table = ts->irq_states;
+ expand_name_table(ts, &nt->irq_names, nt->nb_irqs, new_nb);
+ fill_name_table(ts, nt->irq_names, nt->nb_irqs, new_nb, "irq");
+
+ old_table = ts->irq_states;
ts->irq_states = g_new(LttvIRQState, new_nb);
- memcpy(ts->irq_states, old_table, ts->nb_irqs * sizeof(LttvIRQState));
- for(i = ts->nb_irqs; i < new_nb; i++) {
- ts->irq_states[i].mode_stack = g_array_new(FALSE, FALSE, sizeof(LttvIRQMode));
- }
+ memcpy(ts->irq_states, old_table, nt->nb_irqs * sizeof(LttvIRQState));
+ g_free(old_table);
+ for(i = nt->nb_irqs; i < new_nb; i++)
+ ts->irq_states[i].mode_stack =
+ g_array_new(FALSE, FALSE, sizeof(LttvIRQMode));
/* Update the table size */
- ts->nb_irqs = new_nb;
+ nt->nb_irqs = new_nb;
}
static void expand_soft_irq_table(LttvTraceState *ts, int id)
{
- guint new_nb = check_expand(ts->nb_soft_irqs, id);
- guint i;
- if(likely(new_nb == ts->nb_soft_irqs))
+ LttvNameTables *nt = ts->name_tables;
+ LttvSoftIRQState *old_table;
+ guint new_nb, i;
+
+ new_nb = check_expand(nt->nb_soft_irqs, id);
+ if(likely(new_nb == nt->nb_soft_irqs))
return;
- expand_name_table(ts, &ts->soft_irq_names, ts->nb_soft_irqs, new_nb);
- fill_name_table(ts, ts->soft_irq_names, ts->nb_soft_irqs, new_nb, "softirq");
- LttvSoftIRQState *old_table = ts->soft_irq_states;
+ expand_name_table(ts, &nt->soft_irq_names, nt->nb_soft_irqs, new_nb);
+ fill_name_table(ts, nt->soft_irq_names, nt->nb_soft_irqs, new_nb, "softirq");
+
+ old_table = ts->soft_irq_states;
ts->soft_irq_states = g_new(LttvSoftIRQState, new_nb);
memcpy(ts->soft_irq_states, old_table,
- ts->nb_soft_irqs * sizeof(LttvSoftIRQState));
- for(i = ts->nb_soft_irqs; i < new_nb; i++)
+ nt->nb_soft_irqs * sizeof(LttvSoftIRQState));
+ g_free(old_table);
+ for(i = nt->nb_soft_irqs; i < new_nb; i++)
ts->soft_irq_states[i].running = 0;
/* Update the table size */
- ts->nb_soft_irqs = new_nb;
+ nt->nb_soft_irqs = new_nb;
}
static void
//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;
- nb_soft_irqs = self->nb_soft_irqs;
- nb_traps = self->nb_traps;
+ nb_irqs = self->name_tables->nb_irqs;
+ nb_soft_irqs = self->name_tables->nb_soft_irqs;
+ nb_traps = self->name_tables->nb_traps;
/* Put the per cpu running_process to beginning state : process 0. */
for(i=0; i< nb_cpus; i++) {
nb_tracefile = tc->tracefiles->len;
nb_cpu = ltt_trace_get_num_cpu(tc->t);
- nb_irq = tcs->nb_irqs;
+ nb_irq = tcs->name_tables->nb_irqs;
tcs->processes = NULL;
tcs->usertraces = NULL;
tcs->running_process = g_new(LttvProcessState*, nb_cpu);
/* init soft irq stuff */
/* the kernel has a statically fixed max of 32 softirqs */
- tcs->soft_irq_states = g_new(LttvSoftIRQState, tcs->nb_soft_irqs);
+ tcs->soft_irq_states = g_new(LttvSoftIRQState, tcs->name_tables->nb_soft_irqs);
/* init trap stuff */
- tcs->trap_states = g_new(LttvTrapState, tcs->nb_traps);
+ tcs->trap_states = g_new(LttvTrapState, tcs->name_tables->nb_traps);
/* init bdev resource stuff */
tcs->bdev_states = g_hash_table_new(g_int_hash, g_int_equal);
}
/* save the irq state */
- nb_irqs = self->nb_irqs;
+ nb_irqs = self->name_tables->nb_irqs;
{
value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_IRQS,
LTTV_POINTER);
}
/* save the soft irq state */
- nb_soft_irqs = self->nb_soft_irqs;
+ nb_soft_irqs = self->name_tables->nb_soft_irqs;
{
value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_SOFT_IRQS,
LTTV_POINTER);
}
/* save the trap state */
- nb_traps = self->nb_traps;
+ nb_traps = self->name_tables->nb_traps;
{
value = lttv_attribute_add(container, LTTV_STATE_RESOURCE_TRAPS,
LTTV_POINTER);
LttEventPosition *ep;
LttvTracesetContext *tsc = self->parent.ts_context;
+ int retval;
tracefiles_tree = lttv_attribute_find_subdir(container,
LTTV_STATE_TRACEFILES);
self->cpu_states = lttv_state_copy_cpu_states(*(value.v_pointer), nb_cpus);
/* restore irq resource states */
- nb_irqs = self->nb_irqs;
+ nb_irqs = self->name_tables->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 soft irq resource states */
- nb_soft_irqs = self->nb_soft_irqs;
+ nb_soft_irqs = self->name_tables->nb_soft_irqs;
type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_SOFT_IRQS, &value);
g_assert(type == LTTV_POINTER);
lttv_state_free_soft_irq_states(self->soft_irq_states, nb_soft_irqs);
self->soft_irq_states = lttv_state_copy_soft_irq_states(*(value.v_pointer), nb_soft_irqs);
/* restore trap resource states */
- nb_traps = self->nb_traps;
+ nb_traps = self->name_tables->nb_traps;
type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_TRAPS, &value);
g_assert(type == LTTV_POINTER);
lttv_state_free_trap_states(self->trap_states, nb_traps);
g_tree_remove(tsc->pqueue, tfc);
if(ep != NULL) {
- g_assert(ltt_tracefile_seek_position(tfc->tf, ep) == 0);
+ retval= ltt_tracefile_seek_position(tfc->tf, ep);
+ g_assert_cmpint(retval, ==, 0);
tfc->timestamp = ltt_event_time(ltt_tracefile_get_event(tfc->tf));
- g_assert(ltt_time_compare(tfc->timestamp, ltt_time_infinite) != 0);
+ g_assert_cmpint(ltt_time_compare(tfc->timestamp, ltt_time_infinite), !=, 0);
g_tree_insert(tsc->pqueue, tfc, tfc);
g_info("Restoring state for a tf at time %lu.%lu", tfc->timestamp.tv_sec, tfc->timestamp.tv_nsec);
} else {
static void state_saved_free(LttvTraceState *self, LttvAttribute *container)
{
- guint i, nb_tracefile, nb_cpus, nb_irqs, nb_softirqs;
+ guint i, nb_tracefile, nb_cpus, nb_irqs, nb_soft_irqs;
LttvTracefileState *tfcs;
lttv_state_free_cpu_states(*(value.v_pointer), nb_cpus);
/* free irq resource states */
- nb_irqs = self->nb_irqs;
+ nb_irqs = self->name_tables->nb_irqs;
type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_IRQS, &value);
g_assert(type == LTTV_POINTER);
lttv_state_free_irq_states(*(value.v_pointer), nb_irqs);
/* free softirq resource states */
- nb_softirqs = self->nb_irqs;
+ nb_soft_irqs = self->name_tables->nb_soft_irqs;
type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_SOFT_IRQS, &value);
g_assert(type == LTTV_POINTER);
- lttv_state_free_soft_irq_states(*(value.v_pointer), nb_softirqs);
+ lttv_state_free_soft_irq_states(*(value.v_pointer), nb_soft_irqs);
/* free the blkdev states */
type = lttv_attribute_get_by_name(container, LTTV_STATE_RESOURCE_BLKDEVS, &value);
*(v.v_pointer) = NULL;
}
-
-typedef struct _LttvNameTables {
- // FIXME GQuark *eventtype_names;
- GQuark *syscall_names;
- guint nb_syscalls;
- GQuark *trap_names;
- guint nb_traps;
- GQuark *irq_names;
- guint nb_irqs;
- GQuark *soft_irq_names;
- guint nb_softirqs;
- GHashTable *kprobe_hash;
-} LttvNameTables;
-
-
static void
create_name_tables(LttvTraceState *tcs)
{
*/
/* the kernel is limited to 32 statically defined softirqs */
- name_tables->nb_softirqs = 32;
- name_tables->soft_irq_names = g_new(GQuark, name_tables->nb_softirqs);
- for(i = 0 ; i < name_tables->nb_softirqs ; i++) {
+ name_tables->nb_soft_irqs = 32;
+ name_tables->soft_irq_names = g_new(GQuark, name_tables->nb_soft_irqs);
+ for(i = 0 ; i < name_tables->nb_soft_irqs ; i++) {
g_string_printf(fe_name, "softirq %d", i);
name_tables->soft_irq_names[i] = g_quark_from_string(fe_name->str);
}
g_string_free(fe_name, TRUE);
-#if (__SIZEOF_LONG__ == 4)
+#if (__WORDSIZE == 32)
name_tables->kprobe_hash = g_hash_table_new_full(guint64_hash, guint64_equal,
g_free, NULL);
#else
static void
get_name_tables(LttvTraceState *tcs)
{
- LttvNameTables *name_tables;
-
LttvAttributeValue v;
lttv_attribute_find(tcs->parent.t_a, LTTV_STATE_NAME_TABLES,
LTTV_POINTER, &v);
g_assert(*(v.v_pointer) != NULL);
- name_tables = (LttvNameTables *)*(v.v_pointer);
- //tcs->eventtype_names = name_tables->eventtype_names;
- tcs->syscall_names = name_tables->syscall_names;
- tcs->nb_syscalls = name_tables->nb_syscalls;
- tcs->trap_names = name_tables->trap_names;
- tcs->nb_traps = name_tables->nb_traps;
- tcs->irq_names = name_tables->irq_names;
- tcs->soft_irq_names = name_tables->soft_irq_names;
- tcs->nb_irqs = name_tables->nb_irqs;
- tcs->nb_soft_irqs = name_tables->nb_softirqs;
- tcs->kprobe_hash = name_tables->kprobe_hash;
+ tcs->name_tables = (LttvNameTables *)*(v.v_pointer);
}
LttvTraceHook *th = (LttvTraceHook *)hook_data;
struct marker_field *f = lttv_trace_get_hook_field(th, 0);
LttvExecutionSubmode submode;
+ LttvNameTables *nt = ((LttvTraceState *)(s->parent.t_context))->name_tables;
guint syscall = ltt_event_get_unsigned(e, f);
expand_syscall_table(ts, syscall);
- submode = ((LttvTraceState *)(s->parent.t_context))->syscall_names[syscall];
+ submode = nt->syscall_names[syscall];
/* There can be no system call from PID 0 : unknown state */
if(process->pid != 0)
push_state(s, LTTV_STATE_SYSCALL, submode);
LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
LttvTraceHook *th = (LttvTraceHook *)hook_data;
struct marker_field *f = lttv_trace_get_hook_field(th, 0);
+ LttvNameTables *nt = ((LttvTraceState *)(s->parent.t_context))->name_tables;
LttvExecutionSubmode submode;
expand_trap_table(ts, trap);
- submode = ((LttvTraceState *)(s->parent.t_context))->trap_names[trap];
+ submode = nt->trap_names[trap];
push_state(s, LTTV_STATE_TRAP, submode);
//guint8 ev_id = ltt_event_eventtype_id(e);
LttvTraceHook *th = (LttvTraceHook *)hook_data;
struct marker_field *f = lttv_trace_get_hook_field(th, 0);
+ LttvNameTables *nt = ((LttvTraceState *)(s->parent.t_context))->name_tables;
LttvExecutionSubmode submode;
guint64 irq = ltt_event_get_long_unsigned(e, f);
expand_irq_table(ts, irq);
- submode = ((LttvTraceState *)(s->parent.t_context))->irq_names[irq];
+ submode = nt->irq_names[irq];
/* Do something with the info about being in user or system mode when int? */
push_state(s, LTTV_STATE_IRQ, submode);
//guint8 ev_id = ltt_event_eventtype_id(e);
LttvTraceHook *th = (LttvTraceHook *)hook_data;
struct marker_field *f = lttv_trace_get_hook_field(th, 0);
+ LttvNameTables *nt = ((LttvTraceState *)(s->parent.t_context))->name_tables;
LttvExecutionSubmode submode;
guint64 softirq = ltt_event_get_long_unsigned(e, f);
- guint64 nb_softirqs = ((LttvTraceState *)(s->parent.t_context))->nb_soft_irqs;
+ guint64 nb_softirqs = nt->nb_soft_irqs;
if(softirq < nb_softirqs) {
- submode = ((LttvTraceState *)(s->parent.t_context))->soft_irq_names[softirq];
+ submode = nt->soft_irq_names[softirq];
} else {
/* Fixup an incomplete irq table */
GString *string = g_string_new("");
LttvExecutionSubmode submode;
guint64 softirq = ltt_event_get_long_unsigned(e, f);
expand_soft_irq_table(ts, softirq);
- submode = ((LttvTraceState *)(s->parent.t_context))->soft_irq_names[softirq];
+ LttvNameTables *nt = ((LttvTraceState *)(s->parent.t_context))->name_tables;
+ submode = nt->soft_irq_names[softirq];
/* Do something with the info about being in user or system mode when int? */
push_state(s, LTTV_STATE_SOFT_IRQ, submode);
{
LttvTracefileState *s = (LttvTracefileState *)call_data;
LttvTraceState *ts = (LttvTraceState *)s->parent.t_context;
+ LttvNameTables *nt = ts->name_tables;
LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
//guint8 ev_id = ltt_event_eventtype_id(e);
LttvTraceHook *th = (LttvTraceHook *)hook_data;
guint irq = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1));
expand_irq_table(ts, irq);
- ts->irq_names[irq] = action;
+ nt->irq_names[irq] = action;
return FALSE;
}
{
LttvTracefileState *s = (LttvTracefileState *)call_data;
LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
+ LttvNameTables *nt = ts->name_tables;
LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
LttvTraceHook *th = (LttvTraceHook *)hook_data;
guint id;
symbol = ltt_event_get_string(e, lttv_trace_get_hook_field(th, 2));
expand_syscall_table(ts, id);
- ts->syscall_names[id] = g_quark_from_string(symbol);
+ nt->syscall_names[id] = g_quark_from_string(symbol);
return FALSE;
}
{
LttvTracefileState *s = (LttvTracefileState *)call_data;
LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
+ LttvNameTables *nt = ts->name_tables;
LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
LttvTraceHook *th = (LttvTraceHook *)hook_data;
guint id;
symbol = ltt_event_get_string(e, lttv_trace_get_hook_field(th, 2));
expand_soft_irq_table(ts, id);
- ts->soft_irq_names[id] = g_quark_from_string(symbol);
+ nt->soft_irq_names[id] = g_quark_from_string(symbol);
return FALSE;
}
+static gboolean sched_try_wakeup(void *hook_data, void *call_data) {
+
+ LttvTracefileState *s = (LttvTracefileState *)call_data;
+ LttvProcessState *process;
+
+ LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+ LttvTraceHook *th = (LttvTraceHook *)hook_data;
+ gint woken_pid;
+ guint woken_cpu;
+
+ woken_pid = ltt_event_get_int(e, lttv_trace_get_hook_field(th, 0));
+ woken_cpu = ltt_event_get_unsigned(e, lttv_trace_get_hook_field(th, 1));
+
+ process = lttv_state_find_process_or_create(
+ (LttvTraceState*)s->parent.t_context,
+ woken_cpu, woken_pid,
+ &s->parent.timestamp);
+ process->state->s = LTTV_STATE_WAIT_CPU;
+ process->state->change = s->parent.timestamp;
+
+ g_debug("Wakeup: process %d on CPU %u\n", woken_pid, woken_cpu);
+
+ return FALSE;
+
+}
+
static gboolean schedchange(void *hook_data, void *call_data)
{
LttvTracefileState *s = (LttvTracefileState *)call_data;
f = lttv_trace_get_hook_field(th, 1);
filename = ltt_event_get_string(e, f);
- g_hash_table_insert(process->fds, (gpointer)fd, (gpointer)g_quark_from_string(filename));
+ g_hash_table_insert(process->fds, (gpointer)(long)fd,
+ (gpointer)(unsigned long)g_quark_from_string(filename));
return FALSE;
}
LTT_FIELD_PREV_STATE),
schedchange, NULL, &hooks);
+ lttv_trace_find_hook(ts->parent.t,
+ LTT_CHANNEL_KERNEL,
+ LTT_EVENT_SCHED_TRY_WAKEUP,
+ FIELD_ARRAY(LTT_FIELD_PID, LTT_FIELD_CPU_ID, LTT_FIELD_STATE),
+ sched_try_wakeup, NULL, &hooks);
+
lttv_trace_find_hook(ts->parent.t,
LTT_CHANNEL_KERNEL,
LTT_EVENT_PROCESS_FORK,
LTT_FIELD_SYMBOL = g_quark_from_string("symbol");
LTT_FIELD_IP = g_quark_from_string("ip");
LTT_FIELD_FD = g_quark_from_string("fd");
+ LTT_FIELD_STATE = g_quark_from_string("state");
+ LTT_FIELD_CPU_ID = g_quark_from_string("cpu_id");
LTTV_CPU_UNKNOWN = g_quark_from_string("unknown");
LTTV_CPU_IDLE = g_quark_from_string("idle");
projects / lttv.git / blobdiff