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;
12 enum sort_type sort__first_dimension
;
16 LIST_HEAD(hist_entry__sort_list
);
18 static int repsep_snprintf(char *bf
, size_t size
, const char *fmt
, ...)
24 n
= vsnprintf(bf
, size
, fmt
, ap
);
25 if (field_sep
&& n
> 0) {
29 sep
= strchr(sep
, *field_sep
);
39 static int64_t cmp_null(void *l
, void *r
)
52 sort__thread_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
54 return right
->thread
->pid
- left
->thread
->pid
;
57 static int hist_entry__thread_snprintf(struct hist_entry
*self
, char *bf
,
58 size_t size
, unsigned int width
)
60 return repsep_snprintf(bf
, size
, "%*s:%5d", width
,
61 self
->thread
->comm
?: "", self
->thread
->pid
);
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
,
74 sort__comm_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
76 return right
->thread
->pid
- left
->thread
->pid
;
80 sort__comm_collapse(struct hist_entry
*left
, struct hist_entry
*right
)
82 char *comm_l
= left
->thread
->comm
;
83 char *comm_r
= right
->thread
->comm
;
85 if (!comm_l
|| !comm_r
)
86 return cmp_null(comm_l
, comm_r
);
88 return strcmp(comm_l
, comm_r
);
91 static int hist_entry__comm_snprintf(struct hist_entry
*self
, char *bf
,
92 size_t size
, unsigned int width
)
94 return repsep_snprintf(bf
, size
, "%*s", width
, self
->thread
->comm
);
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
,
108 sort__dso_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
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
;
114 if (!dso_l
|| !dso_r
)
115 return cmp_null(dso_l
, dso_r
);
118 dso_name_l
= dso_l
->long_name
;
119 dso_name_r
= dso_r
->long_name
;
121 dso_name_l
= dso_l
->short_name
;
122 dso_name_r
= dso_r
->short_name
;
125 return strcmp(dso_name_l
, dso_name_r
);
128 static int hist_entry__dso_snprintf(struct hist_entry
*self
, char *bf
,
129 size_t size
, unsigned int width
)
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
);
137 return repsep_snprintf(bf
, size
, "%-*s", width
, "[unknown]");
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
,
150 sort__sym_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
154 if (!left
->ms
.sym
&& !right
->ms
.sym
)
155 return right
->level
- left
->level
;
157 if (!left
->ms
.sym
|| !right
->ms
.sym
)
158 return cmp_null(left
->ms
.sym
, right
->ms
.sym
);
160 if (left
->ms
.sym
== right
->ms
.sym
)
163 ip_l
= left
->ms
.sym
->start
;
164 ip_r
= right
->ms
.sym
->start
;
166 return (int64_t)(ip_r
- ip_l
);
169 static int hist_entry__sym_snprintf(struct hist_entry
*self
, char *bf
,
170 size_t size
, unsigned int width __used
)
175 char o
= self
->ms
.map
? dso__symtab_origin(self
->ms
.map
->dso
) : '!';
176 ret
+= repsep_snprintf(bf
, size
, "%-#*llx %c ",
177 BITS_PER_LONG
/ 4, self
->ip
, o
);
181 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "[%c] ", self
->level
);
184 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "%s",
187 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "%-#*llx",
188 BITS_PER_LONG
/ 4, self
->ip
);
193 struct sort_entry sort_sym
= {
194 .se_header
= "Symbol",
195 .se_cmp
= sort__sym_cmp
,
196 .se_snprintf
= hist_entry__sym_snprintf
,
197 .se_width_idx
= HISTC_SYMBOL
,
203 sort__parent_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
205 struct symbol
*sym_l
= left
->parent
;
206 struct symbol
*sym_r
= right
->parent
;
208 if (!sym_l
|| !sym_r
)
209 return cmp_null(sym_l
, sym_r
);
211 return strcmp(sym_l
->name
, sym_r
->name
);
214 static int hist_entry__parent_snprintf(struct hist_entry
*self
, char *bf
,
215 size_t size
, unsigned int width
)
217 return repsep_snprintf(bf
, size
, "%-*s", width
,
218 self
->parent
? self
->parent
->name
: "[other]");
221 struct sort_entry sort_parent
= {
222 .se_header
= "Parent symbol",
223 .se_cmp
= sort__parent_cmp
,
224 .se_snprintf
= hist_entry__parent_snprintf
,
225 .se_width_idx
= HISTC_PARENT
,
231 sort__cpu_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
233 return right
->cpu
- left
->cpu
;
236 static int hist_entry__cpu_snprintf(struct hist_entry
*self
, char *bf
,
237 size_t size
, unsigned int width
)
239 return repsep_snprintf(bf
, size
, "%-*d", width
, self
->cpu
);
242 struct sort_entry sort_cpu
= {
244 .se_cmp
= sort__cpu_cmp
,
245 .se_snprintf
= hist_entry__cpu_snprintf
,
246 .se_width_idx
= HISTC_CPU
,
249 struct sort_dimension
{
251 struct sort_entry
*entry
;
255 static struct sort_dimension sort_dimensions
[] = {
256 { .name
= "pid", .entry
= &sort_thread
, },
257 { .name
= "comm", .entry
= &sort_comm
, },
258 { .name
= "dso", .entry
= &sort_dso
, },
259 { .name
= "symbol", .entry
= &sort_sym
, },
260 { .name
= "parent", .entry
= &sort_parent
, },
261 { .name
= "cpu", .entry
= &sort_cpu
, },
264 int sort_dimension__add(const char *tok
)
268 for (i
= 0; i
< ARRAY_SIZE(sort_dimensions
); i
++) {
269 struct sort_dimension
*sd
= &sort_dimensions
[i
];
271 if (strncasecmp(tok
, sd
->name
, strlen(tok
)))
274 if (sd
->entry
== &sort_parent
) {
275 int ret
= regcomp(&parent_regex
, parent_pattern
, REG_EXTENDED
);
279 regerror(ret
, &parent_regex
, err
, sizeof(err
));
280 pr_err("Invalid regex: %s\n%s", parent_pattern
, err
);
283 sort__has_parent
= 1;
289 if (sd
->entry
->se_collapse
)
290 sort__need_collapse
= 1;
292 if (list_empty(&hist_entry__sort_list
)) {
293 if (!strcmp(sd
->name
, "pid"))
294 sort__first_dimension
= SORT_PID
;
295 else if (!strcmp(sd
->name
, "comm"))
296 sort__first_dimension
= SORT_COMM
;
297 else if (!strcmp(sd
->name
, "dso"))
298 sort__first_dimension
= SORT_DSO
;
299 else if (!strcmp(sd
->name
, "symbol"))
300 sort__first_dimension
= SORT_SYM
;
301 else if (!strcmp(sd
->name
, "parent"))
302 sort__first_dimension
= SORT_PARENT
;
303 else if (!strcmp(sd
->name
, "cpu"))
304 sort__first_dimension
= SORT_CPU
;
307 list_add_tail(&sd
->entry
->list
, &hist_entry__sort_list
);
316 void setup_sorting(const char * const usagestr
[], const struct option
*opts
)
318 char *tmp
, *tok
, *str
= strdup(sort_order
);
320 for (tok
= strtok_r(str
, ", ", &tmp
);
321 tok
; tok
= strtok_r(NULL
, ", ", &tmp
)) {
322 if (sort_dimension__add(tok
) < 0) {
323 error("Unknown --sort key: `%s'", tok
);
324 usage_with_options(usagestr
, opts
);
331 void sort_entry__setup_elide(struct sort_entry
*self
, struct strlist
*list
,
332 const char *list_name
, FILE *fp
)
334 if (list
&& strlist__nr_entries(list
) == 1) {
336 fprintf(fp
, "# %s: %s\n", list_name
,
337 strlist__entry(list
, 0)->s
);