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 } 333