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