struct tracker_t
{
StackStash *stash;
-
+
size_t n_event_bytes;
size_t n_allocated_bytes;
uint8_t * events;
char *filename = g_strdup_printf (format, pid);
char **result = NULL;
char *contents;
-
+
if (g_file_get_contents (filename, &contents, NULL, NULL))
{
result = g_strsplit (contents, "\n", -1);
-
+
g_free (contents);
}
-
+
g_free (filename);
-
+
return result;
}
{
char **lines;
gboolean done = FALSE;
-
+
if ((lines = get_lines ("/proc/%d/cmdline", pid)))
{
if (lines[0] && strlen (lines[0]) > 0)
if (!done && (lines = get_lines ("/proc/%d/status", pid)))
{
int i;
-
+
for (i = 0; lines[i] != NULL; ++i)
{
if (strncmp ("Name:", lines[i], 5) == 0)
fake_new_map (tracker_t *tracker, pid_t pid)
{
char **lines;
-
+
if ((lines = get_lines ("/proc/%d/maps", pid)))
{
int i;
-
+
for (i = 0; lines[i] != NULL; ++i)
{
char file[256];
gulong offset;
gulong inode;
int count;
-
+
file[255] = '\0';
-
+
count = sscanf (
lines[i], "%lx-%lx %*15s %lx %*x:%*x %lu %255s",
&start, &end, &offset, &inode, file);
-
+
if (count == 5)
{
if (strcmp (file, "[vdso]") == 0)
offset = 0;
inode = 0;
}
-
+
tracker_add_map (tracker, pid, start, end, offset, inode, file);
}
}
-
+
g_strfreev (lines);
}
}
{
GDir *proc = g_dir_open ("/proc", 0, NULL);
const char *name;
-
+
if (!proc)
return;
-
+
while ((name = g_dir_read_name (proc)))
{
pid_t pid;
char *end;
-
+
pid = strtol (name, &end, 10);
-
+
if (*end == 0)
{
fake_new_process (tracker, pid);
fake_new_map (tracker, pid);
}
}
-
+
g_dir_close (proc);
}
{
double first_ms = timeval_to_ms (first);
double second_ms = timeval_to_ms (second);
-
+
return first_ms - second_ms;
}
{
tracker_t *tracker = g_new0 (tracker_t, 1);
GTimeVal before, after;
-
+
tracker->n_event_bytes = 0;
tracker->n_allocated_bytes = DEFAULT_SIZE;
tracker->events = g_malloc (DEFAULT_SIZE);
-
+
tracker->stash = stack_stash_new (NULL);
-
+
g_get_current_time (&before);
-
+
populate_from_proc (tracker);
-
+
g_get_current_time (&after);
-
+
g_print ("Time to populate %f\n", time_diff (&after, &before));
-
+
return tracker;
}
if (tracker->n_allocated_bytes - tracker->n_event_bytes < n_bytes)
{
size_t new_size = tracker->n_allocated_bytes * 2;
-
+
tracker->events = g_realloc (tracker->events, new_size);
-
+
tracker->n_allocated_bytes = new_size;
}
-
+
g_assert (tracker->n_allocated_bytes - tracker->n_event_bytes >= n_bytes);
-
+
memcpy (tracker->events + tracker->n_event_bytes, event, n_bytes);
tracker->n_event_bytes += n_bytes;
event.header = MAKE_HEADER (NEW_PROCESS, pid);
COPY_STRING (event.command_line, command_line);
-
+
tracker_append (tracker, &event, sizeof (event));
}
const char *filename)
{
new_map_t event;
-
+
event.header = MAKE_HEADER (NEW_MAP, pid);
COPY_STRING (event.filename, filename);
event.start = start;
event.end = end;
event.offset = offset;
event.inode = inode;
-
+
tracker_append (tracker, &event, sizeof (event));
}
int n_ips)
{
sample_t event;
-
+
event.header = MAKE_HEADER (SAMPLE, pid);
event.trace = stack_stash_add_trace (tracker->stash, ips, n_ips, 1);
-
+
tracker_append (tracker, &event, sizeof (event));
}
struct process_t
{
pid_t pid;
-
+
char * comm;
-
+
GPtrArray * maps;
};
map_t *map;
int i;
pid_t pid = GET_PID (new_map->header);
-
+
process = g_hash_table_lookup (
state->processes_by_pid, GINT_TO_POINTER (pid));
-
+
if (!process)
return;
-
+
map = g_new0 (map_t, 1);
map->filename = g_strdup (new_map->filename);
map->start = new_map->start;
map->end = new_map->end;
map->offset = new_map->offset;
map->inode = new_map->inode;
-
+
/* Remove existing maps that overlap the new one */
for (i = 0; i < process->maps->len; ++i)
{
map_t *m = process->maps->pdata[i];
-
+
if (m->start < map->end && m->end > map->start)
{
destroy_map (m);
-
+
g_ptr_array_remove_index (process->maps, i);
}
}
-
+
g_ptr_array_add (process->maps, map);
}
destroy_process (process_t *process)
{
int i;
-
+
g_free (process->comm);
-
+
for (i = 0; i < process->maps->len; ++i)
{
map_t *map = process->maps->pdata[i];
-
+
destroy_map (map);
}
-
+
g_ptr_array_free (process->maps, TRUE);
g_free (process);
}
create_process (state_t *state, new_process_t *new_process)
{
process_t *process = g_new0 (process_t, 1);
-
+
process->pid = GET_PID (new_process->header);
process->comm = g_strdup (new_process->command_line);
process->maps = g_ptr_array_new ();
#if 0
g_print ("new comm process %d\n", new_process->pid);
#endif
-
+
g_hash_table_insert (
state->processes_by_pid, GINT_TO_POINTER (process->pid), process);
}
#if 0
g_print ("new child %d\n", fork->child_pid);
#endif
-
+
process->pid = fork->child_pid;
process->comm = g_strdup (parent? parent->comm : "<unknown>");
process->maps = g_ptr_array_new ();
-
+
if (parent)
{
for (i = 0; i < parent->maps->len; ++i)
{
map_t *map = copy_map (parent->maps->pdata[i]);
-
+
g_ptr_array_add (process->maps, map);
}
}
-
+
g_hash_table_insert (
state->processes_by_pid, GINT_TO_POINTER (process->pid), process);
}
#if 0
g_print ("Exit for %d\n", exit->pid);
#endif
-
+
/* ignore for now */
}
free_process (gpointer data)
{
process_t *process = data;
-
+
destroy_process (process);
}
state_new (void)
{
state_t *state = g_new0 (state_t, 1);
-
+
state->processes_by_pid =
g_hash_table_new_full (g_direct_hash, g_direct_equal,
NULL, free_process);
-
+
state->unique_symbols = g_hash_table_new (g_direct_hash, g_direct_equal);
state->unique_comms = g_hash_table_new (g_str_hash, g_str_equal);
state->bin_files = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free,
(GDestroyNotify)bin_file_free);
-
+
return state;
-}
+}
static void
state_free (state_t *state)
g_hash_table_destroy (state->unique_symbols);
g_hash_table_destroy (state->unique_comms);
g_hash_table_destroy (state->bin_files);
-
+
g_free (state);
}
parse_kallsym_line (const char *line, GArray *table)
{
char **tokens = g_strsplit_set (line, " \t", -1);
-
+
if (tokens[0] && tokens[1] && tokens[2])
{
glong address;
char *endptr;
-
+
address = strtoul (tokens[0], &endptr, 16);
-
+
if (*endptr == '\0' &&
(strcmp (tokens[1], "T") == 0 ||
strcmp (tokens[1], "t") == 0))
{
kernel_symbol_t sym;
-
+
sym.address = address;
sym.name = g_strdup (tokens[2]);
-
+
g_array_append_val (table, sym);
}
}
-
+
g_strfreev (tokens);
}
{
const char *sol;
const char *eol;
-
+
sol = kallsyms;
eol = strchr (sol, '\n');
while (eol)
{
char *line = g_strndup (sol, eol - sol);
-
+
parse_kallsym_line (line, table);
-
+
g_free (line);
-
+
sol = eol + 1;
eol = strchr (sol, '\n');
}
-
+
if (table->len <= 1)
return FALSE;
-
+
return TRUE;
}
{
const kernel_symbol_t *sym_a = a;
const kernel_symbol_t *sym_b = b;
-
+
if (sym_a->address > sym_b->address)
return 1;
else if (sym_a->address == sym_b->address)
{
if (address >= symbols[last].address)
return &(symbols[last]);
-
+
last--;
}
-
+
return NULL;
}
else
{
int mid = (first + last) / 2;
-
+
if (symbols[mid].address > address)
return do_lookup (symbols, address, first, mid);
else
{
static GArray *kernel_syms;
static gboolean initialized = FALSE;
-
+
#if 0
find_kernel_binary();
#endif
-
+
if (!initialized)
{
char *kallsyms;
if (kallsyms)
{
kernel_syms = g_array_new (TRUE, TRUE, sizeof (kernel_symbol_t));
-
+
if (parse_kallsyms (kallsyms, kernel_syms))
{
g_array_sort (kernel_syms, compare_syms);
kernel_syms = NULL;
}
}
-
+
g_free (kallsyms);
}
-
+
if (!kernel_syms)
{
g_print ("Warning: /proc/kallsyms could not be "
"read. Kernel symbols will not be available\n");
}
-
+
initialized = TRUE;
}
-
+
return kernel_syms;
}
static const char skip_kernel_symbols[][32] =
{
+ /* IRQ stack */
"common_interrupt",
"apic_timer_interrupt",
"smp_apic_timer_interrupt",
"__perf_event_overflow",
"perf_prepare_sample",
"perf_callchain",
+
+ /* NMI stack */
+ "nmi_stack_correct",
+ "do_nmi",
+ "notify_die",
+ "atomic_notifier_call_chain",
+ "notifier_call_chain",
+ "perf_event_nmi_handler",
+ "intel_pmu_handle_irq",
+ "perf_event_overflow",
+ "__perf_event_overflow",
+ "perf_prepare_sample",
+ "perf_callchain",
+
""
};
const char *sym;
const char *s;
int i;
-
+
if (ksyms->len == 0)
return NULL;
-
+
result = do_lookup ((kernel_symbol_t *)ksyms->data, address, 0, ksyms->len - 1);
-
+
sym = result? result->name : NULL;
unique_dup (GHashTable *unique_symbols, const char *sym)
{
char *result;
-
+
result = g_hash_table_lookup (unique_symbols, sym);
if (!result)
{
result = elf_demangle (sym);
g_hash_table_insert (unique_symbols, (char *)sym, result);
}
-
+
return result;
}
process_locate_map (process_t *process, gulong addr)
{
int i;
-
+
for (i = 0; i < process->maps->len; ++i)
{
map_t *map = process->maps->pdata[i];
-
+
if (addr >= map->start && addr < map->end)
return map;
}
-
+
return NULL;
}
else
{
result = message;
-
+
g_hash_table_insert (state->unique_comms, result, result);
}
gboolean kernel)
{
const char *sym;
-
+
g_assert (process);
-
+
if (kernel)
{
sym = lookup_kernel_symbol (address);
else
{
map_t *map = process_locate_map (process, address);
-
+
if (!map)
{
sym = make_message (state, "No map [%s]", process->comm);
{
bin_file_t *bin_file = state_get_bin_file (state, map->filename);
const bin_symbol_t *bin_sym;
-
+
address -= map->start;
address += map->offset;
else
{
bin_sym = bin_file_lookup_symbol (bin_file, address);
-
+
sym = bin_symbol_get_name (bin_file, bin_sym);
}
}
}
-
+
if (sym)
return unique_dup (state->unique_symbols, sym);
else
{
enum perf_callchain_context context;
char name[32];
-};
+};
static const context_info_t context_info[] =
{
get_context_info (enum perf_callchain_context context)
{
int i;
-
+
for (i = 0; i < sizeof (context_info) / sizeof (context_info[0]); ++i)
{
const context_info_t *info = &context_info[i];
-
+
if (info->context == context)
return info;
}
-
+
return NULL;
}
process = g_hash_table_lookup (
state->processes_by_pid, GINT_TO_POINTER (pid));
-
+
if (!process)
{
static gboolean warned;
}
return;
}
-
+
len = 5;
for (n = sample->trace; n != NULL; n = n->parent)
len++;
resolved_traces = g_new (uint64_t, len);
else
resolved_traces = stack_addrs;
-
+
len = 0;
for (n = sample->trace; n != NULL; n = n->parent)
{
uint64_t address = n->data;
const context_info_t *new_context;
const char *symbol;
-
+
new_context = get_context_info (address);
if (new_context)
{
symbol = unique_dup (state->unique_symbols, context->name);
else
symbol = NULL;
-
+
context = new_context;
}
else
{
gboolean kernel = context && context->context == PERF_CONTEXT_KERNEL;
-
+
symbol = lookup_symbol (state, process, address, kernel);
}
-
+
if (symbol)
resolved_traces[len++] = POINTER_TO_U64 (symbol);
}
resolved_traces[len++] =
POINTER_TO_U64 (unique_dup (state->unique_symbols, context->name));
}
-
+
cmdline = make_message (state, "[%s]", process->comm);
-
+
resolved_traces[len++] = POINTER_TO_U64 (cmdline);
resolved_traces[len++] = POINTER_TO_U64 (
unique_dup (state->unique_symbols, everything));
Profile *profile;
state_t *state;
uint8_t *event;
-
+
state = state_new ();
resolved_stash = stack_stash_new (g_free);
-
+
event = tracker->events;
while (event < end)
{
event_type_t type = GET_TYPE (*(uint32_t *)event);
-
+
switch (type)
{
case NEW_PROCESS:
create_process (state, (new_process_t *)event);
event += sizeof (new_process_t);
break;
-
+
case NEW_MAP:
create_map (state, (new_map_t *)event);
event += sizeof (new_map_t);
process_exit (state, (exit_t *)event);
event += sizeof (exit_t);
break;
-
+
case SAMPLE:
process_sample (state, resolved_stash, (sample_t *)event);
event += sizeof (sample_t);
state_free (state);
stack_stash_unref (resolved_stash);
-
+
return profile;
}