#include <ltt/event.h>
#include <ltt/type.h>
#include <stdio.h>
+#include <string.h>
#define PREALLOCATED_EXECUTION_STACK 10
GQuark
LTT_FACILITY_KERNEL,
+ LTT_FACILITY_KERNEL_ARCH,
LTT_FACILITY_PROCESS,
- LTT_FACILITY_FS;
+ LTT_FACILITY_FS,
+ LTT_FACILITY_STATEDUMP;
/* Events Quarks */
LTT_EVENT_TRAP_EXIT,
LTT_EVENT_IRQ_ENTRY,
LTT_EVENT_IRQ_EXIT,
+ LTT_EVENT_SOFT_IRQ_ENTRY,
+ LTT_EVENT_SOFT_IRQ_EXIT,
LTT_EVENT_SCHEDCHANGE,
LTT_EVENT_FORK,
+ LTT_EVENT_KERNEL_THREAD,
LTT_EVENT_EXIT,
LTT_EVENT_FREE,
- LTT_EVENT_EXEC;
+ LTT_EVENT_EXEC,
+ LTT_EVENT_ENUM_PROCESS_STATE;
/* Fields Quarks */
LTT_FIELD_SYSCALL_ID,
LTT_FIELD_TRAP_ID,
LTT_FIELD_IRQ_ID,
+ LTT_FIELD_SOFT_IRQ_ID,
LTT_FIELD_OUT,
LTT_FIELD_IN,
LTT_FIELD_OUT_STATE,
LTT_FIELD_PARENT_PID,
LTT_FIELD_CHILD_PID,
LTT_FIELD_PID,
- LTT_FIELD_FILENAME;
+ LTT_FIELD_FILENAME,
+ LTT_FIELD_NAME,
+ LTT_FIELD_MODE,
+ LTT_FIELD_SUBMODE,
+ LTT_FIELD_STATUS;
LttvExecutionMode
LTTV_STATE_MODE_UNKNOWN,
LTTV_STATE_USER_MODE,
LTTV_STATE_SYSCALL,
LTTV_STATE_TRAP,
- LTTV_STATE_IRQ;
+ LTTV_STATE_IRQ,
+ LTTV_STATE_SOFT_IRQ;
LttvExecutionSubmode
LTTV_STATE_SUBMODE_UNKNOWN,
/* Put the per cpu running_process to beginning state : process 0. */
for(i=0; i< nb_cpus; i++) {
self->running_process[i] = lttv_state_create_process(self, NULL, i, 0,
- <t_time_zero);
+ LTTV_STATE_UNNAMED, <t_time_zero);
self->running_process[i]->state->s = LTTV_STATE_RUN;
self->running_process[i]->cpu = i;
}
GQuark *syscall_names;
GQuark *trap_names;
GQuark *irq_names;
+ GQuark *soft_irq_names;
} LttvNameTables;
}
#endif //0
if(lttv_trace_find_hook(tcs->parent.t,
- LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_ENTRY,
+ LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY,
LTT_FIELD_SYSCALL_ID, 0, 0,
NULL, NULL, &h))
return;
thf = lttv_trace_hook_get_first(&h);
t = ltt_field_type(thf->f1);
- //nb = ltt_type_element_number(t);
+ nb = ltt_type_element_number(t);
lttv_trace_hook_destroy(&h);
- /* CHECK syscalls should be an enum but currently are not!
name_tables->syscall_names = g_new(GQuark, nb);
for(i = 0 ; i < nb ; i++) {
- name_tables->syscall_names[i] = g_quark_from_string(
- ltt_enum_string_get(t, i));
+ name_tables->syscall_names[i] = ltt_enum_string_get(t, i);
}
- */
- name_tables->syscall_names = g_new(GQuark, 256);
- for(i = 0 ; i < 256 ; i++) {
- g_string_printf(fe_name, "syscall %d", i);
- name_tables->syscall_names[i] = g_quark_from_string(fe_name->str);
- }
+ //name_tables->syscall_names = g_new(GQuark, 256);
+ //for(i = 0 ; i < 256 ; i++) {
+ // g_string_printf(fe_name, "syscall %d", i);
+ // name_tables->syscall_names[i] = g_quark_from_string(fe_name->str);
+ //}
if(lttv_trace_find_hook(tcs->parent.t, LTT_FACILITY_KERNEL,
LTT_EVENT_TRAP_ENTRY,
name_tables->irq_names[i] = g_quark_from_string(fe_name->str);
}
+ /*
+ name_tables->soft_irq_names = g_new(GQuark, nb);
+ for(i = 0 ; i < nb ; i++) {
+ name_tables->soft_irq_names[i] = g_quark_from_string(ltt_enum_string_get(t, i));
+ }
+ */
+
+ name_tables->soft_irq_names = g_new(GQuark, 256);
+ for(i = 0 ; i < 256 ; 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);
}
tcs->syscall_names = name_tables->syscall_names;
tcs->trap_names = name_tables->trap_names;
tcs->irq_names = name_tables->irq_names;
+ tcs->soft_irq_names = name_tables->soft_irq_names;
}
g_free(name_tables->syscall_names);
g_free(name_tables->trap_names);
g_free(name_tables->irq_names);
+ g_free(name_tables->soft_irq_names);
g_free(name_tables);
}
LttvProcessState *
lttv_state_create_process(LttvTraceState *tcs, LttvProcessState *parent,
- guint cpu, guint pid, const LttTime *timestamp)
+ guint cpu, guint pid, GQuark name, const LttTime *timestamp)
{
LttvProcessState *process = g_new(LttvProcessState, 1);
process->pid = pid;
process->cpu = cpu;
+ process->name = name;
//process->last_cpu = tfs->cpu_name;
//process->last_cpu_index = ltt_tracefile_num(((LttvTracefileContext*)tfs)->tf);
+ process->kernel_thread = 0;
+
g_info("Process %u, core %p", process->pid, process);
g_hash_table_insert(tcs->processes, process, process);
if(parent) {
process->ppid = parent->pid;
- process->name = parent->name;
process->creation_time = *timestamp;
}
else {
process->ppid = 0;
- process->name = LTTV_STATE_UNNAMED;
process->creation_time = ltt_time_zero;
}
LttTime *timestamp)
{
LttvProcessState *process = lttv_state_find_process(ts, cpu, pid);
+ LttvExecutionState *es;
/* Put ltt_time_zero creation time for unexisting processes */
- if(unlikely(process == NULL)) process = lttv_state_create_process(ts,
- NULL, cpu, pid, timestamp);
+ if(unlikely(process == NULL)) {
+ process = lttv_state_create_process(ts,
+ NULL, cpu, pid, LTTV_STATE_UNNAMED, timestamp);
+ /* We are not sure is it's a kernel thread or normal thread, put the
+ * bottom stack state to unknown */
+ es = &g_array_index(process->execution_stack, LttvExecutionState, 0);
+ es->t = LTTV_STATE_MODE_UNKNOWN;
+ }
return process;
}
return FALSE;
}
+static gboolean soft_irq_entry(void *hook_data, void *call_data)
+{
+ LttvTracefileState *s = (LttvTracefileState *)call_data;
+ 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;
+ // g_assert(lttv_trace_hook_get_first((LttvTraceHook *)hook_data)->f1 != NULL);
+ g_assert(thf->f1 != NULL);
+ // g_assert(thf == lttv_trace_hook_get_first((LttvTraceHook *)hook_data));
+ LttField *f = thf->f1;
+
+ LttvExecutionSubmode submode;
+
+ submode = ((LttvTraceState *)(s->parent.t_context))->soft_irq_names[
+ ltt_event_get_unsigned(e, f)];
+
+ /* Do something with the info about being in user or system mode when int? */
+ push_state(s, LTTV_STATE_SOFT_IRQ, submode);
+ return FALSE;
+}
+
+
+static gboolean soft_irq_exit(void *hook_data, void *call_data)
+{
+ LttvTracefileState *s = (LttvTracefileState *)call_data;
+
+ pop_state(s, LTTV_STATE_SOFT_IRQ);
+ return FALSE;
+}
+
static gboolean schedchange(void *hook_data, void *call_data)
{
guint cpu = ltt_tracefile_num(s->parent.tf);
LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
LttvProcessState *process = ts->running_process[cpu];
+ LttvProcessState *old_process = ts->running_process[cpu];
LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
the wrongly attributed statistics. */
//This test only makes sense once the state is known and if there is no
- //missing events.
+ //missing events. We need to silently ignore schedchange coming after a
+ //process_free, or it causes glitches. (FIXME)
//if(unlikely(process->pid != pid_out)) {
// g_assert(process->pid == 0);
//}
else process->state->s = LTTV_STATE_WAIT;
process->state->change = s->parent.timestamp;
}
-
- if(state_out == 32)
+
+ if(state_out == 32)
exit_process(s, process); /* EXIT_DEAD */
/* see sched.h for states */
}
LttvTracefileState *s = (LttvTracefileState *)call_data;
LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
- LttField *f;
guint parent_pid;
guint child_pid;
LttvProcessState *zombie_process;
LttvProcessState *child_process;
/* Parent PID */
- f = thf->f1;
- parent_pid = ltt_event_get_unsigned(e, f);
+ parent_pid = ltt_event_get_unsigned(e, thf->f1);
/* Child PID */
- f = thf->f2;
- child_pid = ltt_event_get_unsigned(e, f);
+ child_pid = ltt_event_get_unsigned(e, thf->f2);
/* Mathieu : it seems like the process might have been scheduled in before the
* fork, and, in a rare case, might be the current process. This might happen
// g_assert(process->pid == parent_pid);
child_process = lttv_state_find_process(ts, ANY_CPU, child_pid);
if(child_process == NULL) {
- lttv_state_create_process(ts, process, cpu,
- child_pid, &s->parent.timestamp);
+ child_process = lttv_state_create_process(ts, process, cpu,
+ child_pid, LTTV_STATE_UNNAMED, &s->parent.timestamp);
} else {
/* The process has already been created : due to time imprecision between
* multiple CPUs : it has been scheduled in before creation. Note that we
before the fork event */
child_process->ppid = process->pid;
}
+ g_assert(child_process->name == LTTV_STATE_UNNAMED);
+ child_process->name = process->name;
return FALSE;
}
+/* We stamp a newly created process as kernel_thread */
+static gboolean process_kernel_thread(void *hook_data, void *call_data)
+{
+ LttvTracefileState *s = (LttvTracefileState *)call_data;
+ LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+ LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
+ guint pid;
+ guint cpu = ltt_tracefile_num(s->parent.tf);
+ LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
+ LttvProcessState *process;
+ LttvExecutionState *es;
+
+ /* PID */
+ pid = ltt_event_get_unsigned(e, thf->f1);
+
+ process = lttv_state_find_process(ts, ANY_CPU, pid);
+ es = &g_array_index(process->execution_stack, LttvExecutionState, 0);
+ es->t = LTTV_STATE_SYSCALL;
+ process->kernel_thread = 1;
+
+ return FALSE;
+}
static gboolean process_exit(void *hook_data, void *call_data)
{
break;
}
}
- if(i == num_cpus) /* process is not scheduled */
- exit_process(s, process);
+ //if(i == num_cpus) /* process is not scheduled */
+ //exit_process(s, process); // do nothing : wait for the schedchange to
+ //delete the process.
}
return FALSE;
return FALSE;
}
+static gboolean enum_process_state(void *hook_data, void *call_data)
+{
+ LttvTracefileState *s = (LttvTracefileState *)call_data;
+ LttEvent *e = ltt_tracefile_get_event(s->parent.tf);
+ //It's slow : optimise later by doing this before reading trace.
+ LttEventType *et = ltt_event_eventtype(e);
+ //
+ LttvTraceHookByFacility *thf = (LttvTraceHookByFacility *)hook_data;
+ guint parent_pid;
+ guint pid;
+ gchar * command;
+ guint cpu = ltt_tracefile_num(s->parent.tf);
+ LttvTraceState *ts = (LttvTraceState*)s->parent.t_context;
+ LttvProcessState *process = ts->running_process[cpu];
+ LttvProcessState *parent_process;
+ LttField *f4, *f5, *f6;
+ GQuark mode, submode, status;
+ /* PID */
+ pid = ltt_event_get_unsigned(e, thf->f1);
+
+ /* Parent PID */
+ parent_pid = ltt_event_get_unsigned(e, thf->f2);
+
+ /* Command name */
+ command = ltt_event_get_string(e, thf->f3);
+
+ /* mode */
+ f4 = ltt_eventtype_field_by_name(et, LTT_FIELD_MODE);
+ mode = ltt_enum_string_get(ltt_field_type(f4),
+ ltt_event_get_unsigned(e, f4));
+
+ /* submode */
+ f5 = ltt_eventtype_field_by_name(et, LTT_FIELD_SUBMODE);
+ submode = ltt_enum_string_get(ltt_field_type(f5),
+ ltt_event_get_unsigned(e, f5));
+
+ /* status */
+ f6 = ltt_eventtype_field_by_name(et, LTT_FIELD_STATUS);
+ status = ltt_enum_string_get(ltt_field_type(f6),
+ ltt_event_get_unsigned(e, f6));
+
+ /* The process might exist if a process was forked while performing the sate dump. */
+ process = lttv_state_find_process(ts, ANY_CPU, pid);
+ if(process == NULL) {
+ parent_process = lttv_state_find_process(ts, ANY_CPU, parent_pid);
+ process = lttv_state_create_process(ts, parent_process, cpu,
+ pid, g_quark_from_string(command),
+ &s->parent.timestamp);
+
+ /* Keep the stack bottom : a running user mode */
+#if 0
+ /* Disabled because of inconsistencies in the current statedump states. */
+ if(mode == LTTV_STATE_USER_MODE) {
+ /* Only keep the bottom */
+ process->execution_stack = g_array_set_size(process->execution_stack, 1);
+ } else {
+ /* On top of it : */
+ LttvExecutionState *es;
+ es = process->state = &g_array_index(process->execution_stack,
+ LttvExecutionState, 1);
+ es->t = mode;
+ es->s = status;
+ es->n = submode;
+ }
+#endif //0
+ /* UNKNOWN STATE */
+ {
+ LttvExecutionState *es;
+ es = process->state = &g_array_index(process->execution_stack,
+ LttvExecutionState, 1);
+ es->t = LTTV_STATE_MODE_UNKNOWN;
+ es->s = LTTV_STATE_UNNAMED;
+ es->n = LTTV_STATE_SUBMODE_UNKNOWN;
+ }
+ } else {
+ /* The process has already been created :
+ * Probably was forked while dumping the process state or
+ * was simply scheduled in prior to get the state dump event.
+ */
+ process->ppid = parent_pid;
+ process->name = g_quark_from_string(command);
+ /* Don't mess around with the stack, it will eventually become
+ * ok after the end of state dump. */
+ }
+
+ return FALSE;
+}
gint lttv_state_hook_add_event_hooks(void *hook_data, void *call_data)
{
/* Find the eventtype id for the following events and register the
associated by id hooks. */
- hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 11);
- hooks = g_array_set_size(hooks, 11);
+ hooks = g_array_sized_new(FALSE, FALSE, sizeof(LttvTraceHook), 15);
+ hooks = g_array_set_size(hooks, 15);
ret = lttv_trace_find_hook(ts->parent.t,
- LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_ENTRY,
+ LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_ENTRY,
LTT_FIELD_SYSCALL_ID, 0, 0,
syscall_entry, NULL, &g_array_index(hooks, LttvTraceHook, 0));
g_assert(!ret);
ret = lttv_trace_find_hook(ts->parent.t,
- LTT_FACILITY_KERNEL, LTT_EVENT_SYSCALL_EXIT,
+ LTT_FACILITY_KERNEL_ARCH, LTT_EVENT_SYSCALL_EXIT,
0, 0, 0,
syscall_exit, NULL, &g_array_index(hooks, LttvTraceHook, 1));
g_assert(!ret);
irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, 5));
g_assert(!ret);
+ ret = lttv_trace_find_hook(ts->parent.t,
+ LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_ENTRY,
+ LTT_FIELD_SOFT_IRQ_ID, 0, 0,
+ soft_irq_entry, NULL, &g_array_index(hooks, LttvTraceHook, 6));
+ g_assert(!ret);
+
+ ret = lttv_trace_find_hook(ts->parent.t,
+ LTT_FACILITY_KERNEL, LTT_EVENT_SOFT_IRQ_EXIT,
+ 0, 0, 0,
+ soft_irq_exit, NULL, &g_array_index(hooks, LttvTraceHook, 7));
+ g_assert(!ret);
+
ret = lttv_trace_find_hook(ts->parent.t,
LTT_FACILITY_PROCESS, LTT_EVENT_SCHEDCHANGE,
LTT_FIELD_OUT, LTT_FIELD_IN, LTT_FIELD_OUT_STATE,
- schedchange, NULL, &g_array_index(hooks, LttvTraceHook, 6));
+ schedchange, NULL, &g_array_index(hooks, LttvTraceHook, 8));
g_assert(!ret);
ret = lttv_trace_find_hook(ts->parent.t,
LTT_FACILITY_PROCESS, LTT_EVENT_FORK,
LTT_FIELD_PARENT_PID, LTT_FIELD_CHILD_PID, 0,
- process_fork, NULL, &g_array_index(hooks, LttvTraceHook, 7));
+ process_fork, NULL, &g_array_index(hooks, LttvTraceHook, 9));
+ g_assert(!ret);
+
+ ret = lttv_trace_find_hook(ts->parent.t,
+ LTT_FACILITY_PROCESS, LTT_EVENT_KERNEL_THREAD,
+ LTT_FIELD_PID, 0, 0,
+ process_kernel_thread, NULL, &g_array_index(hooks, LttvTraceHook, 10));
g_assert(!ret);
ret = lttv_trace_find_hook(ts->parent.t,
LTT_FACILITY_PROCESS, LTT_EVENT_EXIT,
LTT_FIELD_PID, 0, 0,
- process_exit, NULL, &g_array_index(hooks, LttvTraceHook, 8));
+ process_exit, NULL, &g_array_index(hooks, LttvTraceHook, 11));
g_assert(!ret);
ret = lttv_trace_find_hook(ts->parent.t,
LTT_FACILITY_PROCESS, LTT_EVENT_FREE,
LTT_FIELD_PID, 0, 0,
- process_free, NULL, &g_array_index(hooks, LttvTraceHook, 9));
+ process_free, NULL, &g_array_index(hooks, LttvTraceHook, 12));
g_assert(!ret);
ret = lttv_trace_find_hook(ts->parent.t,
LTT_FACILITY_FS, LTT_EVENT_EXEC,
LTT_FIELD_FILENAME, 0, 0,
- process_exec, NULL, &g_array_index(hooks, LttvTraceHook, 10));
+ process_exec, NULL, &g_array_index(hooks, LttvTraceHook, 13));
g_assert(!ret);
+ /* statedump-related hooks */
+ ret = lttv_trace_find_hook(ts->parent.t,
+ LTT_FACILITY_STATEDUMP, LTT_EVENT_ENUM_PROCESS_STATE,
+ LTT_FIELD_PID, LTT_FIELD_PARENT_PID, LTT_FIELD_NAME,
+ enum_process_state, NULL, &g_array_index(hooks, LttvTraceHook, 14));
+ g_assert(!ret);
-
+
/* Add these hooks to each event_by_id hooks list */
nb_tracefile = ts->parent.tracefiles->len;
}
}
}
- lttv_attribute_find(self->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
+ lttv_attribute_find(ts->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
*(val.v_pointer) = hooks;
}
}
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);
+ lttv_attribute_find(ts->parent.a, LTTV_STATE_HOOKS, LTTV_POINTER, &val);
hooks = *(val.v_pointer);
/* Remove these hooks from each event_by_id hooks list */
static void module_init()
{
LTTV_STATE_UNNAMED = g_quark_from_string("unnamed");
- LTTV_STATE_MODE_UNKNOWN = g_quark_from_string("unknown execution mode");
- 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_SUBMODE_UNKNOWN = g_quark_from_string("unknown submode");
- LTTV_STATE_SUBMODE_NONE = g_quark_from_string("(no submode)");
- LTTV_STATE_WAIT_CPU = g_quark_from_string("wait for cpu");
- LTTV_STATE_EXIT = g_quark_from_string("exiting");
- LTTV_STATE_ZOMBIE = g_quark_from_string("zombie");
- LTTV_STATE_WAIT = g_quark_from_string("wait for I/O");
- LTTV_STATE_RUN = g_quark_from_string("running");
- LTTV_STATE_DEAD = g_quark_from_string("dead");
+ LTTV_STATE_MODE_UNKNOWN = g_quark_from_string("MODE_UNKNOWN");
+ LTTV_STATE_USER_MODE = g_quark_from_string("USER_MODE");
+ LTTV_STATE_SYSCALL = g_quark_from_string("SYSCALL");
+ LTTV_STATE_TRAP = g_quark_from_string("TRAP");
+ LTTV_STATE_IRQ = g_quark_from_string("IRQ");
+ LTTV_STATE_SOFT_IRQ = g_quark_from_string("SOFTIRQ");
+ LTTV_STATE_SUBMODE_UNKNOWN = g_quark_from_string("UNKNOWN");
+ LTTV_STATE_SUBMODE_NONE = g_quark_from_string("NONE");
+ LTTV_STATE_WAIT_FORK = g_quark_from_string("WAIT_FORK");
+ LTTV_STATE_WAIT_CPU = g_quark_from_string("WAIT_CPU");
+ LTTV_STATE_EXIT = g_quark_from_string("EXIT");
+ LTTV_STATE_ZOMBIE = g_quark_from_string("ZOMBIE");
+ LTTV_STATE_WAIT = g_quark_from_string("WAIT");
+ LTTV_STATE_RUN = g_quark_from_string("RUN");
+ LTTV_STATE_DEAD = g_quark_from_string("DEAD");
LTTV_STATE_TRACEFILES = g_quark_from_string("tracefiles");
LTTV_STATE_PROCESSES = g_quark_from_string("processes");
LTTV_STATE_PROCESS = g_quark_from_string("process");
LTT_FACILITY_KERNEL = g_quark_from_string("kernel");
+ LTT_FACILITY_KERNEL_ARCH = g_quark_from_string("kernel_arch");
LTT_FACILITY_PROCESS = g_quark_from_string("process");
LTT_FACILITY_FS = g_quark_from_string("fs");
+ LTT_FACILITY_STATEDUMP = g_quark_from_string("statedump");
LTT_EVENT_SYSCALL_ENTRY = g_quark_from_string("syscall_entry");
LTT_EVENT_TRAP_EXIT = g_quark_from_string("trap_exit");
LTT_EVENT_IRQ_ENTRY = g_quark_from_string("irq_entry");
LTT_EVENT_IRQ_EXIT = g_quark_from_string("irq_exit");
+ LTT_EVENT_SOFT_IRQ_ENTRY = g_quark_from_string("soft_irq_entry");
+ LTT_EVENT_SOFT_IRQ_EXIT = g_quark_from_string("soft_irq_exit");
LTT_EVENT_SCHEDCHANGE = g_quark_from_string("schedchange");
LTT_EVENT_FORK = g_quark_from_string("fork");
+ LTT_EVENT_KERNEL_THREAD = g_quark_from_string("kernel_thread");
LTT_EVENT_EXIT = g_quark_from_string("exit");
LTT_EVENT_FREE = g_quark_from_string("free");
LTT_EVENT_EXEC = g_quark_from_string("exec");
+ LTT_EVENT_ENUM_PROCESS_STATE = g_quark_from_string("enumerate_process_state");
LTT_FIELD_SYSCALL_ID = g_quark_from_string("syscall_id");
LTT_FIELD_TRAP_ID = g_quark_from_string("trap_id");
LTT_FIELD_IRQ_ID = g_quark_from_string("irq_id");
+ LTT_FIELD_SOFT_IRQ_ID = g_quark_from_string("softirq_id");
LTT_FIELD_OUT = g_quark_from_string("out");
LTT_FIELD_IN = g_quark_from_string("in");
LTT_FIELD_OUT_STATE = g_quark_from_string("out_state");
LTT_FIELD_CHILD_PID = g_quark_from_string("child_pid");
LTT_FIELD_PID = g_quark_from_string("pid");
LTT_FIELD_FILENAME = g_quark_from_string("filename");
+ LTT_FIELD_NAME = g_quark_from_string("name");
+ LTT_FIELD_MODE = g_quark_from_string("mode");
+ LTT_FIELD_SUBMODE = g_quark_from_string("submode");
+ LTT_FIELD_STATUS = g_quark_from_string("status");
}
projects / lttv.git / blobdiff