static void
process_event(struct pevent *pevent, struct pevent_record *record, int type)
{
struct event_format *event;
const char *event_name;
unsigned long long val;
int pid;
int ret;
if (pending_pid >= 0) {
save_call_chain(pending_pid, pending_ips, pending_ips_idx, 1);
reset_pending_stack();
}
event = pevent_data_event_from_type(pevent, type);
event_name = event->name;
ret = pevent_read_number_field(common_pid_field, record->data, &val);
if (ret < 0)
die("no pid field for function?");
pid = val;
/*
* Even if function or function graph tracer is running,
* if the user ran with stack traces on events, we want to use
* that instead. But unfortunately, that stack doesn't come
* until after the event. Thus, we only add the event into
* the pending stack.
*/
push_stack_func(event_name);
copy_stack_to_pending(pid);
pop_stack_func();
}
static void do_trace_mem(struct tracecmd_input *handle)
{
struct pevent *pevent = tracecmd_get_pevent(handle);
struct event_format *event;
struct pevent_record *record;
int missed_events = 0;
int cpus;
int cpu;
int ret;
ret = tracecmd_init_data(handle);
if (ret < 0)
die("failed to init data");
if (ret > 0)
die("trace-cmd mem does not work with latency traces\n");
cpus = tracecmd_cpus(handle);
/* Need to get any event */
for (cpu = 0; cpu < cpus; cpu++) {
record = tracecmd_peek_data(handle, cpu);
if (record)
break;
}
if (!record)
die("No records found in file");
ret = pevent_data_type(pevent, record);
event = pevent_data_event_from_type(pevent, ret);
common_type_field = pevent_find_common_field(event, "common_type");
if (!common_type_field)
die("Can't find a 'type' field?");
update_kmalloc(pevent);
update_kmalloc_node(pevent);
update_kfree(pevent);
update_kmem_cache_alloc(pevent);
update_kmem_cache_alloc_node(pevent);
update_kmem_cache_free(pevent);
while ((record = tracecmd_read_next_data(handle, &cpu))) {
/* record missed event */
if (!missed_events && record->missed_events)
missed_events = 1;
process_record(pevent, record);
free_record(record);
}
sort_list();
print_list();
}
void
trace_view_store_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
gint column,
GValue *value)
{
TraceViewRecord *record;
TraceViewStore *trace_view_store;
struct trace_seq s;
struct pevent *pevent;
struct event_format *event;
struct record *data;
const gchar *comm;
gchar *str;
guint64 secs, usecs;
gint val;
int cpu;
g_return_if_fail (TRACE_VIEW_IS_LIST (tree_model));
g_return_if_fail (iter != NULL);
g_return_if_fail (column < TRACE_VIEW_STORE(tree_model)->n_columns);
g_value_init (value, TRACE_VIEW_STORE(tree_model)->column_types[column]);
trace_view_store = TRACE_VIEW_STORE(tree_model);
pevent = tracecmd_get_pevent(trace_view_store->handle);
record = (TraceViewRecord*)iter->user_data;
g_return_if_fail ( record != NULL );
column = get_visible_column(TRACE_VIEW_STORE(tree_model), column);
switch(column)
{
case TRACE_VIEW_STORE_COL_INDEX:
g_value_set_uint(value, record->pos);
break;
case TRACE_VIEW_STORE_COL_CPU:
g_value_set_uint(value, record->cpu);
break;
case TRACE_VIEW_STORE_COL_TS:
usecs = record->timestamp;
usecs /= 1000;
secs = usecs / 1000000ULL;
usecs -= secs * 1000000ULL;
str = g_strdup_printf("%llu.%06llu",
(long long)secs, (long long)usecs);
g_value_set_string(value, str);
g_free(str);
break;
case TRACE_VIEW_STORE_COL_COMM:
case TRACE_VIEW_STORE_COL_PID:
case TRACE_VIEW_STORE_COL_LAT:
case TRACE_VIEW_STORE_COL_EVENT:
case TRACE_VIEW_STORE_COL_INFO:
data = tracecmd_read_at(trace_view_store->handle, record->offset, &cpu);
g_assert(data != NULL);
if (cpu != record->cpu) {
free_record(data);
return;
}
switch (column) {
case TRACE_VIEW_STORE_COL_COMM:
case TRACE_VIEW_STORE_COL_PID:
val = pevent_data_pid(pevent, data);
if (column == TRACE_VIEW_STORE_COL_PID)
g_value_set_uint(value, val);
else {
comm = pevent_data_comm_from_pid(pevent, val);
g_value_set_string(value, comm);
}
break;
case TRACE_VIEW_STORE_COL_LAT:
trace_seq_init(&s);
pevent_data_lat_fmt(pevent, &s, data);
g_value_set_string(value, s.buffer);
trace_seq_destroy(&s);
break;
case TRACE_VIEW_STORE_COL_EVENT:
case TRACE_VIEW_STORE_COL_INFO:
val = pevent_data_type(pevent, data);
event = pevent_data_event_from_type(pevent, val);
if (!event) {
if (column == TRACE_VIEW_STORE_COL_EVENT)
g_value_set_string(value, "[UNKNOWN EVENT]");
break;
}
if (column == TRACE_VIEW_STORE_COL_EVENT) {
g_value_set_string(value, event->name);
break;
}
trace_seq_init(&s);
pevent_event_info(&s, event, data);
g_value_set_string(value, s.buffer);
trace_seq_destroy(&s);
break;
}
free_record(data);
}
}
static void do_trace_hist(struct tracecmd_input *handle)
{
struct pevent *pevent = tracecmd_get_pevent(handle);
struct event_format *event;
struct pevent_record *record;
int cpus;
int cpu;
int ret;
ret = tracecmd_init_data(handle);
if (ret < 0)
die("failed to init data");
if (ret > 0)
die("trace-cmd hist does not work with latency traces\n");
cpus = tracecmd_cpus(handle);
/* Need to get any event */
for (cpu = 0; cpu < cpus; cpu++) {
record = tracecmd_peek_data(handle, cpu);
if (record)
break;
}
if (!record)
die("No records found in file");
ret = pevent_data_type(pevent, record);
event = pevent_data_event_from_type(pevent, ret);
long_size = tracecmd_long_size(handle);
common_type_field = pevent_find_common_field(event, "common_type");
if (!common_type_field)
die("Can't find a 'type' field?");
common_pid_field = pevent_find_common_field(event, "common_pid");
if (!common_pid_field)
die("Can't find a 'pid' field?");
update_sched_wakeup(pevent);
update_sched_wakeup_new(pevent);
update_sched_switch(pevent);
update_function(pevent);
update_function_graph_entry(pevent);
update_function_graph_exit(pevent);
update_kernel_stack(pevent);
for (cpu = 0; cpu < cpus; cpu++) {
for (;;) {
struct pevent_record *record;
record = tracecmd_read_data(handle, cpu);
if (!record)
break;
/* If we missed events, just flush out the current stack */
if (record->missed_events)
flush_stack();
process_record(pevent, record);
free_record(record);
}
}
if (current_pid >= 0)
save_call_chain(current_pid, ips, ips_idx, 0);
if (pending_pid >= 0)
save_call_chain(pending_pid, pending_ips, pending_ips_idx, 1);
save_stored_stacks();
sort_chains();
print_chains(pevent);
}
