tools/perf/util/sort.c

   1 #include "sort.h"
   2 #include "hist.h"
   3
   4 regex_t         parent_regex;
   5 const char      default_parent_pattern[] = "^sys_|^do_page_fault";
   6 const char      *parent_pattern = default_parent_pattern;
   7 const char      default_sort_order[] = "comm,dso,symbol";
   8 const char      *sort_order = default_sort_order;
   9 int             sort__need_collapse = 0;
  10 int             sort__has_parent = 0;
  11
  12 enum sort_type  sort__first_dimension;
  13
  14 char * field_sep;
  15
  16 LIST_HEAD(hist_entry__sort_list);
  17
  18 static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
  19 {
  20         int n;
  21         va_list ap;
  22
  23         va_start(ap, fmt);
  24         n = vsnprintf(bf, size, fmt, ap);
  25         if (field_sep && n > 0) {
  26                 char *sep = bf;
  27
  28                 while (1) {
  29                         sep = strchr(sep, *field_sep);
  30                         if (sep == NULL)
  31                                 break;
  32                         *sep = '.';
  33                 }
  34         }
  35         va_end(ap);
  36         return n;
  37 }
  38
  39 static int64_t cmp_null(void *l, void *r)
  40 {
  41         if (!l && !r)
  42                 return 0;
  43         else if (!l)
  44                 return -1;
  45         else
  46                 return 1;
  47 }
  48
  49 /* --sort pid */
  50
  51 static int64_t
  52 sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
  53 {
  54         return right->thread->pid - left->thread->pid;
  55 }
  56
  57 static int hist_entry__thread_snprintf(struct hist_entry *self, char *bf,
  58                                        size_t size, unsigned int width)
  59 {
  60         return repsep_snprintf(bf, size, "%*s:%5d", width,
  61                               self->thread->comm ?: "", self->thread->pid);
  62 }
  63
  64 struct sort_entry sort_thread = {
  65         .se_header      = "Command:  Pid",
  66         .se_cmp         = sort__thread_cmp,
  67         .se_snprintf    = hist_entry__thread_snprintf,
  68         .se_width_idx   = HISTC_THREAD,
  69 };
  70
  71 /* --sort comm */
  72
  73 static int64_t
  74 sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
  75 {
  76         return right->thread->pid - left->thread->pid;
  77 }
  78
  79 static int64_t
  80 sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
  81 {
  82         char *comm_l = left->thread->comm;
  83         char *comm_r = right->thread->comm;
  84
  85         if (!comm_l || !comm_r)
  86                 return cmp_null(comm_l, comm_r);
  87
  88         return strcmp(comm_l, comm_r);
  89 }
  90
  91 static int hist_entry__comm_snprintf(struct hist_entry *self, char *bf,
  92                                      size_t size, unsigned int width)
  93 {
  94         return repsep_snprintf(bf, size, "%*s", width, self->thread->comm);
  95 }
  96
  97 struct sort_entry sort_comm = {
  98         .se_header      = "Command",
  99         .se_cmp         = sort__comm_cmp,
 100         .se_collapse    = sort__comm_collapse,
 101         .se_snprintf    = hist_entry__comm_snprintf,
 102         .se_width_idx   = HISTC_COMM,
 103 };
 104
 105 /* --sort dso */
 106
 107 static int64_t
 108 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
 109 {
 110         struct dso *dso_l = left->ms.map ? left->ms.map->dso : NULL;
 111         struct dso *dso_r = right->ms.map ? right->ms.map->dso : NULL;
 112         const char *dso_name_l, *dso_name_r;
 113
 114         if (!dso_l || !dso_r)
 115                 return cmp_null(dso_l, dso_r);
 116
 117         if (verbose) {
 118                 dso_name_l = dso_l->long_name;
 119                 dso_name_r = dso_r->long_name;
 120         } else {
 121                 dso_name_l = dso_l->short_name;
 122                 dso_name_r = dso_r->short_name;
 123         }
 124
 125         return strcmp(dso_name_l, dso_name_r);
 126 }
 127
 128 static int hist_entry__dso_snprintf(struct hist_entry *self, char *bf,
 129                                     size_t size, unsigned int width)
 130 {
 131         if (self->ms.map && self->ms.map->dso) {
 132                 const char *dso_name = !verbose ? self->ms.map->dso->short_name :
 133                                                   self->ms.map->dso->long_name;
 134                 return repsep_snprintf(bf, size, "%-*s", width, dso_name);
 135         }
 136
 137         return repsep_snprintf(bf, size, "%-*s", width, "[unknown]");
 138 }
 139
 140 struct sort_entry sort_dso = {
 141         .se_header      = "Shared Object",
 142         .se_cmp         = sort__dso_cmp,
 143         .se_snprintf    = hist_entry__dso_snprintf,
 144         .se_width_idx   = HISTC_DSO,
 145 };
 146
 147 /* --sort symbol */
 148
 149 static int64_t
 150 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
 151 {
 152         u64 ip_l, ip_r;
 153
 154         if (left->ms.sym == right->ms.sym)
 155                 return 0;
 156
 157         ip_l = left->ms.sym ? left->ms.sym->start : left->ip;
 158         ip_r = right->ms.sym ? right->ms.sym->start : right->ip;
 159
 160         return (int64_t)(ip_r - ip_l);
 161 }
 162
 163 static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
 164                                     size_t size, unsigned int width __used)
 165 {
 166         size_t ret = 0;
 167
 168         if (verbose) {
 169                 char o = self->ms.map ? dso__symtab_origin(self->ms.map->dso) : '!';
 170                 ret += repsep_snprintf(bf, size, "%-#*llx %c ",
 171                                        BITS_PER_LONG / 4, self->ip, o);
 172         }
 173
 174         ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", self->level);
 175         if (self->ms.sym)
 176                 ret += repsep_snprintf(bf + ret, size - ret, "%s",
 177                                        self->ms.sym->name);
 178         else
 179                 ret += repsep_snprintf(bf + ret, size - ret, "%-#*llx",
 180                                        BITS_PER_LONG / 4, self->ip);
 181
 182         return ret;
 183 }
 184
 185 struct sort_entry sort_sym = {
 186         .se_header      = "Symbol",
 187         .se_cmp         = sort__sym_cmp,
 188         .se_snprintf    = hist_entry__sym_snprintf,
 189         .se_width_idx   = HISTC_SYMBOL,
 190 };
 191
 192 /* --sort parent */
 193
 194 static int64_t
 195 sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
 196 {
 197         struct symbol *sym_l = left->parent;
 198         struct symbol *sym_r = right->parent;
 199
 200         if (!sym_l || !sym_r)
 201                 return cmp_null(sym_l, sym_r);
 202
 203         return strcmp(sym_l->name, sym_r->name);
 204 }
 205
 206 static int hist_entry__parent_snprintf(struct hist_entry *self, char *bf,
 207                                        size_t size, unsigned int width)
 208 {
 209         return repsep_snprintf(bf, size, "%-*s", width,
 210                               self->parent ? self->parent->name : "[other]");
 211 }
 212
 213 struct sort_entry sort_parent = {
 214         .se_header      = "Parent symbol",
 215         .se_cmp         = sort__parent_cmp,
 216         .se_snprintf    = hist_entry__parent_snprintf,
 217         .se_width_idx   = HISTC_PARENT,
 218 };
 219
 220 /* --sort cpu */
 221
 222 static int64_t
 223 sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right)
 224 {
 225         return right->cpu - left->cpu;
 226 }
 227
 228 static int hist_entry__cpu_snprintf(struct hist_entry *self, char *bf,
 229                                        size_t size, unsigned int width)
 230 {
 231         return repsep_snprintf(bf, size, "%-*d", width, self->cpu);
 232 }
 233
 234 struct sort_entry sort_cpu = {
 235         .se_header      = "CPU",
 236         .se_cmp         = sort__cpu_cmp,
 237         .se_snprintf    = hist_entry__cpu_snprintf,
 238         .se_width_idx   = HISTC_CPU,
 239 };
 240
 241 struct sort_dimension {
 242         const char              *name;
 243         struct sort_entry       *entry;
 244         int                     taken;
 245 };
 246
 247 static struct sort_dimension sort_dimensions[] = {
 248         { .name = "pid",        .entry = &sort_thread,  },
 249         { .name = "comm",       .entry = &sort_comm,    },
 250         { .name = "dso",        .entry = &sort_dso,     },
 251         { .name = "symbol",     .entry = &sort_sym,     },
 252         { .name = "parent",     .entry = &sort_parent,  },
 253         { .name = "cpu",        .entry = &sort_cpu,     },
 254 };
 255
 256 int sort_dimension__add(const char *tok)
 257 {
 258         unsigned int i;
 259
 260         for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
 261                 struct sort_dimension *sd = &sort_dimensions[i];
 262
 263                 if (strncasecmp(tok, sd->name, strlen(tok)))
 264                         continue;
 265
 266                 if (sd->entry == &sort_parent) {
 267                         int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
 268                         if (ret) {
 269                                 char err[BUFSIZ];
 270
 271                                 regerror(ret, &parent_regex, err, sizeof(err));
 272                                 pr_err("Invalid regex: %s\n%s", parent_pattern, err);
 273                                 return -EINVAL;
 274                         }
 275                         sort__has_parent = 1;
 276                 }
 277
 278                 if (sd->taken)
 279                         return 0;
 280
 281                 if (sd->entry->se_collapse)
 282                         sort__need_collapse = 1;
 283
 284                 if (list_empty(&hist_entry__sort_list)) {
 285                         if (!strcmp(sd->name, "pid"))
 286                                 sort__first_dimension = SORT_PID;
 287                         else if (!strcmp(sd->name, "comm"))
 288                                 sort__first_dimension = SORT_COMM;
 289                         else if (!strcmp(sd->name, "dso"))
 290                                 sort__first_dimension = SORT_DSO;
 291                         else if (!strcmp(sd->name, "symbol"))
 292                                 sort__first_dimension = SORT_SYM;
 293                         else if (!strcmp(sd->name, "parent"))
 294                                 sort__first_dimension = SORT_PARENT;
 295                         else if (!strcmp(sd->name, "cpu"))
 296                                 sort__first_dimension = SORT_CPU;
 297                 }
 298
 299                 list_add_tail(&sd->entry->list, &hist_entry__sort_list);
 300                 sd->taken = 1;
 301
 302                 return 0;
 303         }
 304
 305         return -ESRCH;
 306 }
 307
 308 void setup_sorting(const char * const usagestr[], const struct option *opts)
 309 {
 310         char *tmp, *tok, *str = strdup(sort_order);
 311
 312         for (tok = strtok_r(str, ", ", &tmp);
 313                         tok; tok = strtok_r(NULL, ", ", &tmp)) {
 314                 if (sort_dimension__add(tok) < 0) {
 315                         error("Unknown --sort key: `%s'", tok);
 316                         usage_with_options(usagestr, opts);
 317                 }
 318         }
 319
 320         free(str);
 321 }
 322
 323 void sort_entry__setup_elide(struct sort_entry *self, struct strlist *list,
 324                              const char *list_name, FILE *fp)
 325 {
 326         if (list && strlist__nr_entries(list) == 1) {
 327                 if (fp != NULL)
 328                         fprintf(fp, "# %s: %s\n", list_name,
 329                                 strlist__entry(list, 0)->s);
 330                 self->elide = true;
 331         }
 332 }