LTT_EVENT_SOFT_IRQ_ENTRY,
LTT_EVENT_SOFT_IRQ_EXIT,
LTT_EVENT_SCHED_SCHEDULE,
+ LTT_EVENT_SCHED_TRY_WAKEUP,
LTT_EVENT_PROCESS_FORK,
LTT_EVENT_KTHREAD_CREATE,
LTT_EVENT_PROCESS_EXIT,
LTT_EVENT_SYS_CALL_TABLE,
LTT_EVENT_SOFTIRQ_VEC,
LTT_EVENT_KPROBE_TABLE,
- LTT_EVENT_KPROBE;
+ LTT_EVENT_KPROBE,
+ LTT_EVENT_OPEN,
+ LTT_EVENT_READ,
+ LTT_EVENT_POLL_EVENT;
/* Fields Quarks */
LTT_FIELD_ID,
LTT_FIELD_ADDRESS,
LTT_FIELD_SYMBOL,
- LTT_FIELD_IP;
+ LTT_FIELD_IP,
+ LTT_FIELD_FD;
LttvExecutionMode
LTTV_STATE_MODE_UNKNOWN,
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)
{
+ LttvNameTables *nt = ts->name_tables;
#if (__SIZEOF_LONG__ == 4)
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);
g_array_index(process->user_stack, guint64, i);
}
new_process->current_function = process->current_function;
+
+ /* fd hash table stuff */
+ {
+ GHashTableIter it;
+ gpointer key;
+ gpointer value;
+
+ /* copy every item in the hash table */
+ new_process->fds = g_hash_table_new(g_direct_hash, g_direct_equal);
+
+ g_hash_table_iter_init(&it, process->fds);
+ while (g_hash_table_iter_next (&it, (void *)&key, (void *)&value)) {
+ g_hash_table_insert(new_process->fds, key, value);
+ }
+ }
+
+ /* When done creating the new process state, insert it in the
+ * hash table */
g_hash_table_insert(new_processes, new_process, new_process);
}
}
/* 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);
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);
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);
}
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);
}
if(name_tables->trap_names) g_free(name_tables->trap_names);
if(name_tables->irq_names) g_free(name_tables->irq_names);
if(name_tables->soft_irq_names) g_free(name_tables->soft_irq_names);
- if(name_tables) g_free(name_tables);
- if(name_tables) g_hash_table_destroy(name_tables->kprobe_hash);
+ g_hash_table_destroy(name_tables->kprobe_hash);
+ g_free(name_tables);
}
#ifdef HASH_TABLE_DEBUG
return tfs;
}
+/* Return a new and initialized LttvProcessState structure */
LttvProcessState *
lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent,
/* Allocate an empty function call stack. If it's empty, use 0x0. */
process->user_stack = g_array_sized_new(FALSE, FALSE,
sizeof(guint64), 0);
+
+ process->fds = g_hash_table_new(g_direct_hash, g_direct_equal);
return process;
}
/* FIXME : this function should be called when we receive an event telling that
* release_task has been called in the kernel. In happens generally when
- * the parent waits for its child terminaison, but may also happen in special
+ * the parent waits for its child termination, but may also happens in special
* cases in the child's exit : when the parent ignores its children SIGCCHLD or
* has the flag SA_NOCLDWAIT. It can also happen when the child is part
* of a killed thread group, but isn't the leader.
g_hash_table_remove(ts->processes, &key);
g_array_free(process->execution_stack, TRUE);
g_array_free(process->user_stack, TRUE);
+
+ /* the following also clears the content */
+ g_hash_table_destroy(process->fds);
+
g_free(process);
return 1;
}
{
g_array_free(((LttvProcessState *)value)->execution_stack, TRUE);
g_array_free(((LttvProcessState *)value)->user_stack, TRUE);
+
+ /* the following also clears the content */
+ g_hash_table_destroy(((LttvProcessState *)value)->fds);
+
g_free(value);
}
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;
}
return FALSE;
}
+static gboolean fs_open(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);
+ LttvTraceHook *th = (LttvTraceHook *)hook_data;
+ struct marker_field *f;
+ guint cpu = s->cpu;
+ int fd;
+ char *filename;
+ LttvProcessState *process = ts->running_process[cpu];
+
+ f = lttv_trace_get_hook_field(th, 0);
+ fd = ltt_event_get_int(e, f);
+
+ f = lttv_trace_get_hook_field(th, 1);
+ filename = ltt_event_get_string(e, f);
+
+ g_hash_table_insert(process->fds, (gpointer)(long)fd,
+ (gpointer)(unsigned long)g_quark_from_string(filename));
+
+ return FALSE;
+}
+
static void fix_process(gpointer key, gpointer value,
gpointer user_data)
{
FIELD_ARRAY(LTT_FIELD_ID, LTT_FIELD_ADDRESS, LTT_FIELD_SYMBOL),
dump_softirq, NULL, &hooks);
+ lttv_trace_find_hook(ts->parent.t,
+ LTT_CHANNEL_FS,
+ LTT_EVENT_OPEN,
+ FIELD_ARRAY(LTT_FIELD_FD, LTT_FIELD_FILENAME),
+ fs_open, NULL, &hooks);
+
/* Add these hooks to each event_by_id hooks list */
nb_tracefile = ts->parent.tracefiles->len;
LTT_EVENT_SOFT_IRQ_ENTRY = g_quark_from_string("softirq_entry");
LTT_EVENT_SOFT_IRQ_EXIT = g_quark_from_string("softirq_exit");
LTT_EVENT_SCHED_SCHEDULE = g_quark_from_string("sched_schedule");
+ LTT_EVENT_SCHED_TRY_WAKEUP = g_quark_from_string("sched_try_wakeup");
LTT_EVENT_PROCESS_FORK = g_quark_from_string("process_fork");
LTT_EVENT_KTHREAD_CREATE = g_quark_from_string("kthread_create");
LTT_EVENT_PROCESS_EXIT = g_quark_from_string("process_exit");
LTT_EVENT_SOFTIRQ_VEC = g_quark_from_string("softirq_vec");
LTT_EVENT_KPROBE_TABLE = g_quark_from_string("kprobe_table");
LTT_EVENT_KPROBE = g_quark_from_string("kprobe");
+ LTT_EVENT_OPEN = g_quark_from_string("open");
+ LTT_EVENT_READ = g_quark_from_string("read");
+ LTT_EVENT_POLL_EVENT = g_quark_from_string("poll_event");
LTT_FIELD_SYSCALL_ID = g_quark_from_string("syscall_id");
LTT_FIELD_TRAP_ID = g_quark_from_string("trap_id");
LTT_FIELD_ADDRESS = g_quark_from_string("address");
LTT_FIELD_SYMBOL = g_quark_from_string("symbol");
LTT_FIELD_IP = g_quark_from_string("ip");
+ LTT_FIELD_FD = g_quark_from_string("fd");
LTTV_CPU_UNKNOWN = g_quark_from_string("unknown");
LTTV_CPU_IDLE = g_quark_from_string("idle");