![Arnaldo Carvalho de Melo](/assets/img/avatar_default.png)
Representing modules as struct map entries, backed by a DSO, etc, using /proc/modules to find where the module is loaded. DSOs now can have a short and long name, so that in verbose mode we can show exactly which .ko or vmlinux image was used. As kernel modules now are a DSO separate from the kernel, we can ask for just the hits for a particular set of kernel modules, just like we can do with shared libraries: [root@doppio linux-2.6-tip]# perf report -n --vmlinux /home/acme/git/build/tip-recvmmsg/vmlinux --modules --dsos \[drm\] | head -15 84.58% 13266 Xorg [k] drm_clflush_pages 4.02% 630 Xorg [k] trace_kmalloc.clone.0 3.95% 619 Xorg [k] drm_ioctl 2.07% 324 Xorg [k] drm_addbufs 1.68% 263 Xorg [k] drm_gem_close_ioctl 0.77% 120 Xorg [k] drm_setmaster_ioctl 0.70% 110 Xorg [k] drm_lastclose 0.68% 106 Xorg [k] drm_open 0.54% 85 Xorg [k] drm_mm_search_free [root@doppio linux-2.6-tip]# Specifying --dsos /lib/modules/2.6.31-tip/kernel/drivers/gpu/drm/drm.ko would have the same effect. Allowing specifying just 'drm.ko' is left for another patch. Processing kallsyms so that per kernel module struct map are instantiated was also left for another patch. That will allow removing the module name from each of its symbols. struct symbol was reduced by removing the ->module backpointer and moving it (well now the map) to struct symbol_entry in perf top, that is its only user right now. The total linecount went down by ~500 lines. Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com> Cc: Frédéric Weisbecker <fweisbec@gmail.com> Cc: "H. Peter Anvin" <hpa@zytor.com> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Mike Galbraith <efault@gmx.de> Cc: Avi Kivity <avi@redhat.com> Signed-off-by: Ingo Molnar <mingo@elte.hu>
277 lines
5.6 KiB
C
277 lines
5.6 KiB
C
#include "sort.h"
|
|
|
|
regex_t parent_regex;
|
|
char default_parent_pattern[] = "^sys_|^do_page_fault";
|
|
char *parent_pattern = default_parent_pattern;
|
|
char default_sort_order[] = "comm,dso,symbol";
|
|
char *sort_order = default_sort_order;
|
|
int sort__need_collapse = 0;
|
|
int sort__has_parent = 0;
|
|
|
|
unsigned int dsos__col_width;
|
|
unsigned int comms__col_width;
|
|
unsigned int threads__col_width;
|
|
static unsigned int parent_symbol__col_width;
|
|
char * field_sep;
|
|
|
|
LIST_HEAD(hist_entry__sort_list);
|
|
|
|
struct sort_entry sort_thread = {
|
|
.header = "Command: Pid",
|
|
.cmp = sort__thread_cmp,
|
|
.print = sort__thread_print,
|
|
.width = &threads__col_width,
|
|
};
|
|
|
|
struct sort_entry sort_comm = {
|
|
.header = "Command",
|
|
.cmp = sort__comm_cmp,
|
|
.collapse = sort__comm_collapse,
|
|
.print = sort__comm_print,
|
|
.width = &comms__col_width,
|
|
};
|
|
|
|
struct sort_entry sort_dso = {
|
|
.header = "Shared Object",
|
|
.cmp = sort__dso_cmp,
|
|
.print = sort__dso_print,
|
|
.width = &dsos__col_width,
|
|
};
|
|
|
|
struct sort_entry sort_sym = {
|
|
.header = "Symbol",
|
|
.cmp = sort__sym_cmp,
|
|
.print = sort__sym_print,
|
|
};
|
|
|
|
struct sort_entry sort_parent = {
|
|
.header = "Parent symbol",
|
|
.cmp = sort__parent_cmp,
|
|
.print = sort__parent_print,
|
|
.width = &parent_symbol__col_width,
|
|
};
|
|
|
|
struct sort_dimension {
|
|
const char *name;
|
|
struct sort_entry *entry;
|
|
int taken;
|
|
};
|
|
|
|
static struct sort_dimension sort_dimensions[] = {
|
|
{ .name = "pid", .entry = &sort_thread, },
|
|
{ .name = "comm", .entry = &sort_comm, },
|
|
{ .name = "dso", .entry = &sort_dso, },
|
|
{ .name = "symbol", .entry = &sort_sym, },
|
|
{ .name = "parent", .entry = &sort_parent, },
|
|
};
|
|
|
|
int64_t cmp_null(void *l, void *r)
|
|
{
|
|
if (!l && !r)
|
|
return 0;
|
|
else if (!l)
|
|
return -1;
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
/* --sort pid */
|
|
|
|
int64_t
|
|
sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
|
|
{
|
|
return right->thread->pid - left->thread->pid;
|
|
}
|
|
|
|
int repsep_fprintf(FILE *fp, const char *fmt, ...)
|
|
{
|
|
int n;
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
if (!field_sep)
|
|
n = vfprintf(fp, fmt, ap);
|
|
else {
|
|
char *bf = NULL;
|
|
n = vasprintf(&bf, fmt, ap);
|
|
if (n > 0) {
|
|
char *sep = bf;
|
|
|
|
while (1) {
|
|
sep = strchr(sep, *field_sep);
|
|
if (sep == NULL)
|
|
break;
|
|
*sep = '.';
|
|
}
|
|
}
|
|
fputs(bf, fp);
|
|
free(bf);
|
|
}
|
|
va_end(ap);
|
|
return n;
|
|
}
|
|
|
|
size_t
|
|
sort__thread_print(FILE *fp, struct hist_entry *self, unsigned int width)
|
|
{
|
|
return repsep_fprintf(fp, "%*s:%5d", width - 6,
|
|
self->thread->comm ?: "", self->thread->pid);
|
|
}
|
|
|
|
size_t
|
|
sort__comm_print(FILE *fp, struct hist_entry *self, unsigned int width)
|
|
{
|
|
return repsep_fprintf(fp, "%*s", width, self->thread->comm);
|
|
}
|
|
|
|
/* --sort dso */
|
|
|
|
int64_t
|
|
sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
|
|
{
|
|
struct dso *dso_l = left->map ? left->map->dso : NULL;
|
|
struct dso *dso_r = right->map ? right->map->dso : NULL;
|
|
const char *dso_name_l, *dso_name_r;
|
|
|
|
if (!dso_l || !dso_r)
|
|
return cmp_null(dso_l, dso_r);
|
|
|
|
if (verbose) {
|
|
dso_name_l = dso_l->long_name;
|
|
dso_name_r = dso_r->long_name;
|
|
} else {
|
|
dso_name_l = dso_l->short_name;
|
|
dso_name_r = dso_r->short_name;
|
|
}
|
|
|
|
return strcmp(dso_name_l, dso_name_r);
|
|
}
|
|
|
|
size_t
|
|
sort__dso_print(FILE *fp, struct hist_entry *self, unsigned int width)
|
|
{
|
|
if (self->map && self->map->dso) {
|
|
const char *dso_name = !verbose ? self->map->dso->short_name :
|
|
self->map->dso->long_name;
|
|
return repsep_fprintf(fp, "%-*s", width, dso_name);
|
|
}
|
|
|
|
return repsep_fprintf(fp, "%*llx", width, (u64)self->ip);
|
|
}
|
|
|
|
/* --sort symbol */
|
|
|
|
int64_t
|
|
sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
|
|
{
|
|
u64 ip_l, ip_r;
|
|
|
|
if (left->sym == right->sym)
|
|
return 0;
|
|
|
|
ip_l = left->sym ? left->sym->start : left->ip;
|
|
ip_r = right->sym ? right->sym->start : right->ip;
|
|
|
|
return (int64_t)(ip_r - ip_l);
|
|
}
|
|
|
|
|
|
size_t
|
|
sort__sym_print(FILE *fp, struct hist_entry *self, unsigned int width __used)
|
|
{
|
|
size_t ret = 0;
|
|
|
|
if (verbose) {
|
|
char o = self->map ? dso__symtab_origin(self->map->dso) : '!';
|
|
ret += repsep_fprintf(fp, "%#018llx %c ", (u64)self->ip, o);
|
|
}
|
|
|
|
ret += repsep_fprintf(fp, "[%c] ", self->level);
|
|
if (self->sym)
|
|
ret += repsep_fprintf(fp, "%s", self->sym->name);
|
|
else
|
|
ret += repsep_fprintf(fp, "%#016llx", (u64)self->ip);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* --sort comm */
|
|
|
|
int64_t
|
|
sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
|
|
{
|
|
return right->thread->pid - left->thread->pid;
|
|
}
|
|
|
|
int64_t
|
|
sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
|
|
{
|
|
char *comm_l = left->thread->comm;
|
|
char *comm_r = right->thread->comm;
|
|
|
|
if (!comm_l || !comm_r)
|
|
return cmp_null(comm_l, comm_r);
|
|
|
|
return strcmp(comm_l, comm_r);
|
|
}
|
|
|
|
/* --sort parent */
|
|
|
|
int64_t
|
|
sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
|
|
{
|
|
struct symbol *sym_l = left->parent;
|
|
struct symbol *sym_r = right->parent;
|
|
|
|
if (!sym_l || !sym_r)
|
|
return cmp_null(sym_l, sym_r);
|
|
|
|
return strcmp(sym_l->name, sym_r->name);
|
|
}
|
|
|
|
size_t
|
|
sort__parent_print(FILE *fp, struct hist_entry *self, unsigned int width)
|
|
{
|
|
return repsep_fprintf(fp, "%-*s", width,
|
|
self->parent ? self->parent->name : "[other]");
|
|
}
|
|
|
|
int sort_dimension__add(const char *tok)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
|
|
struct sort_dimension *sd = &sort_dimensions[i];
|
|
|
|
if (sd->taken)
|
|
continue;
|
|
|
|
if (strncasecmp(tok, sd->name, strlen(tok)))
|
|
continue;
|
|
|
|
if (sd->entry->collapse)
|
|
sort__need_collapse = 1;
|
|
|
|
if (sd->entry == &sort_parent) {
|
|
int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
|
|
if (ret) {
|
|
char err[BUFSIZ];
|
|
|
|
regerror(ret, &parent_regex, err, sizeof(err));
|
|
fprintf(stderr, "Invalid regex: %s\n%s",
|
|
parent_pattern, err);
|
|
exit(-1);
|
|
}
|
|
sort__has_parent = 1;
|
|
}
|
|
|
|
list_add_tail(&sd->entry->list, &hist_entry__sort_list);
|
|
sd->taken = 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
return -ESRCH;
|
|
}
|
|
|