Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
a43783ae | 2 | #include <errno.h> |
fd20e811 | 3 | #include <inttypes.h> |
9b5e350c HM |
4 | #include "builtin.h" |
5 | #include "perf.h" | |
6 | ||
7ae811b1 | 7 | #include "util/evlist.h" // for struct evsel_str_handler |
fcf65bf1 | 8 | #include "util/evsel.h" |
9b5e350c HM |
9 | #include "util/symbol.h" |
10 | #include "util/thread.h" | |
11 | #include "util/header.h" | |
6fda2405 | 12 | #include "util/target.h" |
4fd06bd2 | 13 | #include "util/cgroup.h" |
0d2997f7 | 14 | #include "util/callchain.h" |
407b36f6 | 15 | #include "util/lock-contention.h" |
eca949b2 | 16 | #include "util/bpf_skel/lock_data.h" |
9b5e350c | 17 | |
fa0d9846 | 18 | #include <subcmd/pager.h> |
4b6ab94e | 19 | #include <subcmd/parse-options.h> |
9b5e350c | 20 | #include "util/trace-event.h" |
9b7c7728 | 21 | #include "util/tracepoint.h" |
9b5e350c HM |
22 | |
23 | #include "util/debug.h" | |
24 | #include "util/session.h" | |
45694aa7 | 25 | #include "util/tool.h" |
f5fc1412 | 26 | #include "util/data.h" |
ae0f4eb3 | 27 | #include "util/string2.h" |
0d2997f7 | 28 | #include "util/map.h" |
0a277b62 | 29 | #include "util/util.h" |
9b5e350c | 30 | |
f6027053 | 31 | #include <stdio.h> |
9b5e350c HM |
32 | #include <sys/types.h> |
33 | #include <sys/prctl.h> | |
34 | #include <semaphore.h> | |
9b5e350c HM |
35 | #include <math.h> |
36 | #include <limits.h> | |
511e19b9 | 37 | #include <ctype.h> |
9b5e350c HM |
38 | |
39 | #include <linux/list.h> | |
40 | #include <linux/hash.h> | |
877a7a11 | 41 | #include <linux/kernel.h> |
7f7c536f | 42 | #include <linux/zalloc.h> |
6ef81c55 | 43 | #include <linux/err.h> |
0d2997f7 | 44 | #include <linux/stringify.h> |
9b5e350c | 45 | |
e4cef1f6 | 46 | static struct perf_session *session; |
6fda2405 | 47 | static struct target target; |
e4cef1f6 | 48 | |
9b5e350c HM |
49 | /* based on kernel/lockdep.c */ |
50 | #define LOCKHASH_BITS 12 | |
51 | #define LOCKHASH_SIZE (1UL << LOCKHASH_BITS) | |
52 | ||
eef4fee5 | 53 | static struct hlist_head *lockhash_table; |
9b5e350c HM |
54 | |
55 | #define __lockhashfn(key) hash_long((unsigned long)key, LOCKHASH_BITS) | |
56 | #define lockhashentry(key) (lockhash_table + __lockhashfn((key))) | |
57 | ||
e4cef1f6 HM |
58 | static struct rb_root thread_stats; |
59 | ||
0d435bf8 | 60 | static bool combine_locks; |
7c3bcbdf | 61 | static bool show_thread_stats; |
688d2e8d | 62 | static bool show_lock_addrs; |
3477f079 | 63 | static bool show_lock_owner; |
4d1792d0 | 64 | static bool show_lock_cgroups; |
407b36f6 | 65 | static bool use_bpf; |
2d8d0165 | 66 | static unsigned long bpf_map_entries = MAX_ENTRIES; |
96532a83 NK |
67 | static int max_stack_depth = CONTENTION_STACK_DEPTH; |
68 | static int stack_skip = CONTENTION_STACK_SKIP; | |
6282a1f4 | 69 | static int print_nr_entries = INT_MAX / 2; |
7b204399 | 70 | static LIST_HEAD(callstack_filters); |
f6027053 NK |
71 | static const char *output_name = NULL; |
72 | static FILE *lock_output; | |
7b204399 NK |
73 | |
74 | struct callstack_filter { | |
75 | struct list_head list; | |
76 | char name[]; | |
77 | }; | |
0d435bf8 | 78 | |
b4a7eff9 NK |
79 | static struct lock_filter filters; |
80 | ||
eca949b2 | 81 | static enum lock_aggr_mode aggr_mode = LOCK_AGGR_ADDR; |
f9c695a2 | 82 | |
7b204399 NK |
83 | static bool needs_callstack(void) |
84 | { | |
0fba2265 | 85 | return !list_empty(&callstack_filters); |
7b204399 NK |
86 | } |
87 | ||
e4cef1f6 HM |
88 | static struct thread_stat *thread_stat_find(u32 tid) |
89 | { | |
90 | struct rb_node *node; | |
91 | struct thread_stat *st; | |
92 | ||
93 | node = thread_stats.rb_node; | |
94 | while (node) { | |
95 | st = container_of(node, struct thread_stat, rb); | |
96 | if (st->tid == tid) | |
97 | return st; | |
98 | else if (tid < st->tid) | |
99 | node = node->rb_left; | |
100 | else | |
101 | node = node->rb_right; | |
102 | } | |
103 | ||
104 | return NULL; | |
105 | } | |
106 | ||
107 | static void thread_stat_insert(struct thread_stat *new) | |
108 | { | |
109 | struct rb_node **rb = &thread_stats.rb_node; | |
110 | struct rb_node *parent = NULL; | |
111 | struct thread_stat *p; | |
112 | ||
113 | while (*rb) { | |
114 | p = container_of(*rb, struct thread_stat, rb); | |
115 | parent = *rb; | |
116 | ||
117 | if (new->tid < p->tid) | |
118 | rb = &(*rb)->rb_left; | |
119 | else if (new->tid > p->tid) | |
120 | rb = &(*rb)->rb_right; | |
121 | else | |
122 | BUG_ON("inserting invalid thread_stat\n"); | |
123 | } | |
124 | ||
125 | rb_link_node(&new->rb, parent, rb); | |
126 | rb_insert_color(&new->rb, &thread_stats); | |
127 | } | |
128 | ||
129 | static struct thread_stat *thread_stat_findnew_after_first(u32 tid) | |
130 | { | |
131 | struct thread_stat *st; | |
132 | ||
133 | st = thread_stat_find(tid); | |
134 | if (st) | |
135 | return st; | |
136 | ||
137 | st = zalloc(sizeof(struct thread_stat)); | |
33d6aef5 DA |
138 | if (!st) { |
139 | pr_err("memory allocation failed\n"); | |
140 | return NULL; | |
141 | } | |
e4cef1f6 HM |
142 | |
143 | st->tid = tid; | |
144 | INIT_LIST_HEAD(&st->seq_list); | |
145 | ||
146 | thread_stat_insert(st); | |
147 | ||
148 | return st; | |
149 | } | |
150 | ||
151 | static struct thread_stat *thread_stat_findnew_first(u32 tid); | |
152 | static struct thread_stat *(*thread_stat_findnew)(u32 tid) = | |
153 | thread_stat_findnew_first; | |
154 | ||
155 | static struct thread_stat *thread_stat_findnew_first(u32 tid) | |
156 | { | |
157 | struct thread_stat *st; | |
158 | ||
159 | st = zalloc(sizeof(struct thread_stat)); | |
33d6aef5 DA |
160 | if (!st) { |
161 | pr_err("memory allocation failed\n"); | |
162 | return NULL; | |
163 | } | |
e4cef1f6 HM |
164 | st->tid = tid; |
165 | INIT_LIST_HEAD(&st->seq_list); | |
166 | ||
167 | rb_link_node(&st->rb, NULL, &thread_stats.rb_node); | |
168 | rb_insert_color(&st->rb, &thread_stats); | |
169 | ||
170 | thread_stat_findnew = thread_stat_findnew_after_first; | |
171 | return st; | |
172 | } | |
173 | ||
9b5e350c | 174 | /* build simple key function one is bigger than two */ |
59f411b6 | 175 | #define SINGLE_KEY(member) \ |
9b5e350c HM |
176 | static int lock_stat_key_ ## member(struct lock_stat *one, \ |
177 | struct lock_stat *two) \ | |
178 | { \ | |
179 | return one->member > two->member; \ | |
180 | } | |
181 | ||
182 | SINGLE_KEY(nr_acquired) | |
183 | SINGLE_KEY(nr_contended) | |
f37376cd | 184 | SINGLE_KEY(avg_wait_time) |
9b5e350c | 185 | SINGLE_KEY(wait_time_total) |
9b5e350c HM |
186 | SINGLE_KEY(wait_time_max) |
187 | ||
9df03abe MS |
188 | static int lock_stat_key_wait_time_min(struct lock_stat *one, |
189 | struct lock_stat *two) | |
190 | { | |
191 | u64 s1 = one->wait_time_min; | |
192 | u64 s2 = two->wait_time_min; | |
193 | if (s1 == ULLONG_MAX) | |
194 | s1 = 0; | |
195 | if (s2 == ULLONG_MAX) | |
196 | s2 = 0; | |
197 | return s1 > s2; | |
198 | } | |
199 | ||
9b5e350c HM |
200 | struct lock_key { |
201 | /* | |
202 | * name: the value for specify by user | |
203 | * this should be simpler than raw name of member | |
204 | * e.g. nr_acquired -> acquired, wait_time_total -> wait_total | |
205 | */ | |
59f411b6 | 206 | const char *name; |
64999e44 NK |
207 | /* header: the string printed on the header line */ |
208 | const char *header; | |
209 | /* len: the printing width of the field */ | |
210 | int len; | |
211 | /* key: a pointer to function to compare two lock stats for sorting */ | |
59f411b6 | 212 | int (*key)(struct lock_stat*, struct lock_stat*); |
64999e44 NK |
213 | /* print: a pointer to function to print a given lock stats */ |
214 | void (*print)(struct lock_key*, struct lock_stat*); | |
215 | /* list: list entry to link this */ | |
216 | struct list_head list; | |
9b5e350c HM |
217 | }; |
218 | ||
ab010176 NK |
219 | static void lock_stat_key_print_time(unsigned long long nsec, int len) |
220 | { | |
221 | static const struct { | |
222 | float base; | |
223 | const char *unit; | |
224 | } table[] = { | |
225 | { 1e9 * 3600, "h " }, | |
226 | { 1e9 * 60, "m " }, | |
227 | { 1e9, "s " }, | |
228 | { 1e6, "ms" }, | |
229 | { 1e3, "us" }, | |
230 | { 0, NULL }, | |
231 | }; | |
232 | ||
69c5c993 NK |
233 | /* for CSV output */ |
234 | if (len == 0) { | |
f6027053 | 235 | fprintf(lock_output, "%llu", nsec); |
69c5c993 NK |
236 | return; |
237 | } | |
238 | ||
ab010176 NK |
239 | for (int i = 0; table[i].unit; i++) { |
240 | if (nsec < table[i].base) | |
241 | continue; | |
242 | ||
f6027053 | 243 | fprintf(lock_output, "%*.2f %s", len - 3, nsec / table[i].base, table[i].unit); |
ab010176 NK |
244 | return; |
245 | } | |
246 | ||
f6027053 | 247 | fprintf(lock_output, "%*llu %s", len - 3, nsec, "ns"); |
ab010176 NK |
248 | } |
249 | ||
64999e44 NK |
250 | #define PRINT_KEY(member) \ |
251 | static void lock_stat_key_print_ ## member(struct lock_key *key, \ | |
252 | struct lock_stat *ls) \ | |
253 | { \ | |
f6027053 | 254 | fprintf(lock_output, "%*llu", key->len, (unsigned long long)ls->member);\ |
64999e44 NK |
255 | } |
256 | ||
ab010176 NK |
257 | #define PRINT_TIME(member) \ |
258 | static void lock_stat_key_print_ ## member(struct lock_key *key, \ | |
259 | struct lock_stat *ls) \ | |
260 | { \ | |
261 | lock_stat_key_print_time((unsigned long long)ls->member, key->len); \ | |
262 | } | |
263 | ||
64999e44 NK |
264 | PRINT_KEY(nr_acquired) |
265 | PRINT_KEY(nr_contended) | |
ab010176 NK |
266 | PRINT_TIME(avg_wait_time) |
267 | PRINT_TIME(wait_time_total) | |
268 | PRINT_TIME(wait_time_max) | |
64999e44 NK |
269 | |
270 | static void lock_stat_key_print_wait_time_min(struct lock_key *key, | |
271 | struct lock_stat *ls) | |
272 | { | |
273 | u64 wait_time = ls->wait_time_min; | |
274 | ||
275 | if (wait_time == ULLONG_MAX) | |
276 | wait_time = 0; | |
277 | ||
ab010176 | 278 | lock_stat_key_print_time(wait_time, key->len); |
64999e44 NK |
279 | } |
280 | ||
281 | ||
59f411b6 IM |
282 | static const char *sort_key = "acquired"; |
283 | ||
284 | static int (*compare)(struct lock_stat *, struct lock_stat *); | |
285 | ||
0d435bf8 | 286 | static struct rb_root sorted; /* place to store intermediate data */ |
59f411b6 | 287 | static struct rb_root result; /* place to store sorted data */ |
9b5e350c | 288 | |
64999e44 | 289 | static LIST_HEAD(lock_keys); |
4bd9cab5 | 290 | static const char *output_fields; |
64999e44 NK |
291 | |
292 | #define DEF_KEY_LOCK(name, header, fn_suffix, len) \ | |
293 | { #name, header, len, lock_stat_key_ ## fn_suffix, lock_stat_key_print_ ## fn_suffix, {} } | |
79079f21 | 294 | static struct lock_key report_keys[] = { |
64999e44 NK |
295 | DEF_KEY_LOCK(acquired, "acquired", nr_acquired, 10), |
296 | DEF_KEY_LOCK(contended, "contended", nr_contended, 10), | |
ab010176 NK |
297 | DEF_KEY_LOCK(avg_wait, "avg wait", avg_wait_time, 12), |
298 | DEF_KEY_LOCK(wait_total, "total wait", wait_time_total, 12), | |
299 | DEF_KEY_LOCK(wait_max, "max wait", wait_time_max, 12), | |
300 | DEF_KEY_LOCK(wait_min, "min wait", wait_time_min, 12), | |
9b5e350c HM |
301 | |
302 | /* extra comparisons much complicated should be here */ | |
64999e44 | 303 | { } |
9b5e350c HM |
304 | }; |
305 | ||
79079f21 NK |
306 | static struct lock_key contention_keys[] = { |
307 | DEF_KEY_LOCK(contended, "contended", nr_contended, 10), | |
308 | DEF_KEY_LOCK(wait_total, "total wait", wait_time_total, 12), | |
309 | DEF_KEY_LOCK(wait_max, "max wait", wait_time_max, 12), | |
310 | DEF_KEY_LOCK(wait_min, "min wait", wait_time_min, 12), | |
311 | DEF_KEY_LOCK(avg_wait, "avg wait", avg_wait_time, 12), | |
312 | ||
313 | /* extra comparisons much complicated should be here */ | |
314 | { } | |
315 | }; | |
316 | ||
317 | static int select_key(bool contention) | |
9b5e350c HM |
318 | { |
319 | int i; | |
79079f21 NK |
320 | struct lock_key *keys = report_keys; |
321 | ||
322 | if (contention) | |
323 | keys = contention_keys; | |
9b5e350c HM |
324 | |
325 | for (i = 0; keys[i].name; i++) { | |
326 | if (!strcmp(keys[i].name, sort_key)) { | |
327 | compare = keys[i].key; | |
4bd9cab5 NK |
328 | |
329 | /* selected key should be in the output fields */ | |
330 | if (list_empty(&keys[i].list)) | |
331 | list_add_tail(&keys[i].list, &lock_keys); | |
332 | ||
33d6aef5 | 333 | return 0; |
9b5e350c HM |
334 | } |
335 | } | |
336 | ||
33d6aef5 | 337 | pr_err("Unknown compare key: %s\n", sort_key); |
33d6aef5 | 338 | return -1; |
9b5e350c HM |
339 | } |
340 | ||
79079f21 | 341 | static int add_output_field(bool contention, char *name) |
64999e44 NK |
342 | { |
343 | int i; | |
79079f21 NK |
344 | struct lock_key *keys = report_keys; |
345 | ||
346 | if (contention) | |
347 | keys = contention_keys; | |
64999e44 | 348 | |
4bd9cab5 NK |
349 | for (i = 0; keys[i].name; i++) { |
350 | if (strcmp(keys[i].name, name)) | |
351 | continue; | |
352 | ||
353 | /* prevent double link */ | |
354 | if (list_empty(&keys[i].list)) | |
79079f21 | 355 | list_add_tail(&keys[i].list, &lock_keys); |
4bd9cab5 NK |
356 | |
357 | return 0; | |
358 | } | |
359 | ||
360 | pr_err("Unknown output field: %s\n", name); | |
361 | return -1; | |
362 | } | |
363 | ||
79079f21 | 364 | static int setup_output_field(bool contention, const char *str) |
4bd9cab5 NK |
365 | { |
366 | char *tok, *tmp, *orig; | |
367 | int i, ret = 0; | |
79079f21 NK |
368 | struct lock_key *keys = report_keys; |
369 | ||
370 | if (contention) | |
371 | keys = contention_keys; | |
4bd9cab5 NK |
372 | |
373 | /* no output field given: use all of them */ | |
374 | if (str == NULL) { | |
375 | for (i = 0; keys[i].name; i++) | |
376 | list_add_tail(&keys[i].list, &lock_keys); | |
377 | return 0; | |
378 | } | |
379 | ||
64999e44 | 380 | for (i = 0; keys[i].name; i++) |
4bd9cab5 | 381 | INIT_LIST_HEAD(&keys[i].list); |
64999e44 | 382 | |
4bd9cab5 NK |
383 | orig = tmp = strdup(str); |
384 | if (orig == NULL) | |
385 | return -ENOMEM; | |
386 | ||
387 | while ((tok = strsep(&tmp, ",")) != NULL){ | |
79079f21 | 388 | ret = add_output_field(contention, tok); |
4bd9cab5 NK |
389 | if (ret < 0) |
390 | break; | |
391 | } | |
392 | free(orig); | |
393 | ||
394 | return ret; | |
64999e44 NK |
395 | } |
396 | ||
0d435bf8 NK |
397 | static void combine_lock_stats(struct lock_stat *st) |
398 | { | |
399 | struct rb_node **rb = &sorted.rb_node; | |
400 | struct rb_node *parent = NULL; | |
401 | struct lock_stat *p; | |
402 | int ret; | |
403 | ||
404 | while (*rb) { | |
405 | p = container_of(*rb, struct lock_stat, rb); | |
406 | parent = *rb; | |
407 | ||
408 | if (st->name && p->name) | |
409 | ret = strcmp(st->name, p->name); | |
410 | else | |
411 | ret = !!st->name - !!p->name; | |
412 | ||
413 | if (ret == 0) { | |
414 | p->nr_acquired += st->nr_acquired; | |
415 | p->nr_contended += st->nr_contended; | |
416 | p->wait_time_total += st->wait_time_total; | |
417 | ||
418 | if (p->nr_contended) | |
419 | p->avg_wait_time = p->wait_time_total / p->nr_contended; | |
420 | ||
421 | if (p->wait_time_min > st->wait_time_min) | |
422 | p->wait_time_min = st->wait_time_min; | |
423 | if (p->wait_time_max < st->wait_time_max) | |
424 | p->wait_time_max = st->wait_time_max; | |
425 | ||
79d9333b | 426 | p->broken |= st->broken; |
0d435bf8 NK |
427 | st->combined = 1; |
428 | return; | |
429 | } | |
430 | ||
431 | if (ret < 0) | |
432 | rb = &(*rb)->rb_left; | |
433 | else | |
434 | rb = &(*rb)->rb_right; | |
435 | } | |
436 | ||
437 | rb_link_node(&st->rb, parent, rb); | |
438 | rb_insert_color(&st->rb, &sorted); | |
439 | } | |
440 | ||
9b5e350c | 441 | static void insert_to_result(struct lock_stat *st, |
59f411b6 | 442 | int (*bigger)(struct lock_stat *, struct lock_stat *)) |
9b5e350c HM |
443 | { |
444 | struct rb_node **rb = &result.rb_node; | |
445 | struct rb_node *parent = NULL; | |
446 | struct lock_stat *p; | |
447 | ||
0d435bf8 NK |
448 | if (combine_locks && st->combined) |
449 | return; | |
450 | ||
9b5e350c HM |
451 | while (*rb) { |
452 | p = container_of(*rb, struct lock_stat, rb); | |
453 | parent = *rb; | |
454 | ||
455 | if (bigger(st, p)) | |
456 | rb = &(*rb)->rb_left; | |
457 | else | |
458 | rb = &(*rb)->rb_right; | |
459 | } | |
460 | ||
461 | rb_link_node(&st->rb, parent, rb); | |
462 | rb_insert_color(&st->rb, &result); | |
463 | } | |
464 | ||
465 | /* returns left most element of result, and erase it */ | |
466 | static struct lock_stat *pop_from_result(void) | |
467 | { | |
468 | struct rb_node *node = result.rb_node; | |
469 | ||
470 | if (!node) | |
471 | return NULL; | |
472 | ||
473 | while (node->rb_left) | |
474 | node = node->rb_left; | |
475 | ||
476 | rb_erase(node, &result); | |
477 | return container_of(node, struct lock_stat, rb); | |
478 | } | |
479 | ||
16cad1d3 | 480 | struct lock_stat *lock_stat_find(u64 addr) |
3ae03f26 NK |
481 | { |
482 | struct hlist_head *entry = lockhashentry(addr); | |
483 | struct lock_stat *ret; | |
484 | ||
485 | hlist_for_each_entry(ret, entry, hash_entry) { | |
486 | if (ret->addr == addr) | |
487 | return ret; | |
488 | } | |
489 | return NULL; | |
490 | } | |
491 | ||
16cad1d3 | 492 | struct lock_stat *lock_stat_findnew(u64 addr, const char *name, int flags) |
9b5e350c | 493 | { |
7672d00a | 494 | struct hlist_head *entry = lockhashentry(addr); |
9b5e350c HM |
495 | struct lock_stat *ret, *new; |
496 | ||
7672d00a | 497 | hlist_for_each_entry(ret, entry, hash_entry) { |
9b5e350c HM |
498 | if (ret->addr == addr) |
499 | return ret; | |
500 | } | |
501 | ||
502 | new = zalloc(sizeof(struct lock_stat)); | |
503 | if (!new) | |
504 | goto alloc_failed; | |
505 | ||
506 | new->addr = addr; | |
fb87158b | 507 | new->name = strdup(name); |
0a98c7fe DB |
508 | if (!new->name) { |
509 | free(new); | |
9b5e350c | 510 | goto alloc_failed; |
0a98c7fe | 511 | } |
9b5e350c | 512 | |
fb87158b | 513 | new->flags = flags; |
9b5e350c HM |
514 | new->wait_time_min = ULLONG_MAX; |
515 | ||
7672d00a | 516 | hlist_add_head(&new->hash_entry, entry); |
9b5e350c HM |
517 | return new; |
518 | ||
519 | alloc_failed: | |
33d6aef5 DA |
520 | pr_err("memory allocation failed\n"); |
521 | return NULL; | |
9b5e350c HM |
522 | } |
523 | ||
ebab2916 NK |
524 | bool match_callstack_filter(struct machine *machine, u64 *callstack) |
525 | { | |
526 | struct map *kmap; | |
527 | struct symbol *sym; | |
528 | u64 ip; | |
d7c9ae8d | 529 | const char *arch = perf_env__arch(machine->env); |
ebab2916 NK |
530 | |
531 | if (list_empty(&callstack_filters)) | |
532 | return true; | |
533 | ||
534 | for (int i = 0; i < max_stack_depth; i++) { | |
535 | struct callstack_filter *filter; | |
536 | ||
d7c9ae8d KJ |
537 | /* |
538 | * In powerpc, the callchain saved by kernel always includes | |
539 | * first three entries as the NIP (next instruction pointer), | |
540 | * LR (link register), and the contents of LR save area in the | |
541 | * second stack frame. In certain scenarios its possible to have | |
542 | * invalid kernel instruction addresses in either LR or the second | |
543 | * stack frame's LR. In that case, kernel will store that address as | |
544 | * zero. | |
545 | * | |
546 | * The below check will continue to look into callstack, | |
547 | * incase first or second callstack index entry has 0 | |
548 | * address for powerpc. | |
549 | */ | |
550 | if (!callstack || (!callstack[i] && (strcmp(arch, "powerpc") || | |
551 | (i != 1 && i != 2)))) | |
ebab2916 NK |
552 | break; |
553 | ||
554 | ip = callstack[i]; | |
555 | sym = machine__find_kernel_symbol(machine, ip, &kmap); | |
556 | if (sym == NULL) | |
557 | continue; | |
558 | ||
559 | list_for_each_entry(filter, &callstack_filters, list) { | |
560 | if (strstr(sym->name, filter->name)) | |
561 | return true; | |
562 | } | |
563 | } | |
564 | return false; | |
565 | } | |
566 | ||
9b5e350c | 567 | struct trace_lock_handler { |
166a9764 | 568 | /* it's used on CONFIG_LOCKDEP */ |
32dcd021 | 569 | int (*acquire_event)(struct evsel *evsel, |
746f16ec | 570 | struct perf_sample *sample); |
9b5e350c | 571 | |
166a9764 | 572 | /* it's used on CONFIG_LOCKDEP && CONFIG_LOCK_STAT */ |
32dcd021 | 573 | int (*acquired_event)(struct evsel *evsel, |
746f16ec | 574 | struct perf_sample *sample); |
9b5e350c | 575 | |
166a9764 | 576 | /* it's used on CONFIG_LOCKDEP && CONFIG_LOCK_STAT */ |
32dcd021 | 577 | int (*contended_event)(struct evsel *evsel, |
746f16ec | 578 | struct perf_sample *sample); |
9b5e350c | 579 | |
166a9764 | 580 | /* it's used on CONFIG_LOCKDEP */ |
32dcd021 | 581 | int (*release_event)(struct evsel *evsel, |
746f16ec | 582 | struct perf_sample *sample); |
166a9764 NK |
583 | |
584 | /* it's used when CONFIG_LOCKDEP is off */ | |
585 | int (*contention_begin_event)(struct evsel *evsel, | |
586 | struct perf_sample *sample); | |
587 | ||
588 | /* it's used when CONFIG_LOCKDEP is off */ | |
589 | int (*contention_end_event)(struct evsel *evsel, | |
590 | struct perf_sample *sample); | |
9b5e350c HM |
591 | }; |
592 | ||
e1c3177b | 593 | static struct lock_seq_stat *get_seq(struct thread_stat *ts, u64 addr) |
e4cef1f6 HM |
594 | { |
595 | struct lock_seq_stat *seq; | |
596 | ||
597 | list_for_each_entry(seq, &ts->seq_list, list) { | |
598 | if (seq->addr == addr) | |
599 | return seq; | |
600 | } | |
601 | ||
602 | seq = zalloc(sizeof(struct lock_seq_stat)); | |
33d6aef5 DA |
603 | if (!seq) { |
604 | pr_err("memory allocation failed\n"); | |
605 | return NULL; | |
606 | } | |
e4cef1f6 HM |
607 | seq->state = SEQ_STATE_UNINITIALIZED; |
608 | seq->addr = addr; | |
609 | ||
610 | list_add(&seq->list, &ts->seq_list); | |
611 | return seq; | |
612 | } | |
613 | ||
10350ec3 FW |
614 | enum broken_state { |
615 | BROKEN_ACQUIRE, | |
616 | BROKEN_ACQUIRED, | |
617 | BROKEN_CONTENDED, | |
618 | BROKEN_RELEASE, | |
619 | BROKEN_MAX, | |
620 | }; | |
621 | ||
622 | static int bad_hist[BROKEN_MAX]; | |
e4cef1f6 | 623 | |
84c7a217 FW |
624 | enum acquire_flags { |
625 | TRY_LOCK = 1, | |
626 | READ_LOCK = 2, | |
627 | }; | |
628 | ||
0f405f87 | 629 | static int get_key_by_aggr_mode_simple(u64 *key, u64 addr, u32 tid) |
9b5e350c | 630 | { |
f9c695a2 NK |
631 | switch (aggr_mode) { |
632 | case LOCK_AGGR_ADDR: | |
0f405f87 | 633 | *key = addr; |
f9c695a2 NK |
634 | break; |
635 | case LOCK_AGGR_TASK: | |
0f405f87 | 636 | *key = tid; |
f9c695a2 NK |
637 | break; |
638 | case LOCK_AGGR_CALLER: | |
4d1792d0 | 639 | case LOCK_AGGR_CGROUP: |
f9c695a2 NK |
640 | default: |
641 | pr_err("Invalid aggregation mode: %d\n", aggr_mode); | |
642 | return -EINVAL; | |
643 | } | |
0f405f87 SX |
644 | return 0; |
645 | } | |
646 | ||
647 | static u64 callchain_id(struct evsel *evsel, struct perf_sample *sample); | |
648 | ||
649 | static int get_key_by_aggr_mode(u64 *key, u64 addr, struct evsel *evsel, | |
650 | struct perf_sample *sample) | |
651 | { | |
652 | if (aggr_mode == LOCK_AGGR_CALLER) { | |
653 | *key = callchain_id(evsel, sample); | |
654 | return 0; | |
655 | } | |
656 | return get_key_by_aggr_mode_simple(key, addr, sample->tid); | |
657 | } | |
658 | ||
659 | static int report_lock_acquire_event(struct evsel *evsel, | |
660 | struct perf_sample *sample) | |
661 | { | |
662 | struct lock_stat *ls; | |
663 | struct thread_stat *ts; | |
664 | struct lock_seq_stat *seq; | |
665 | const char *name = evsel__strval(evsel, sample, "name"); | |
666 | u64 addr = evsel__intval(evsel, sample, "lockdep_addr"); | |
667 | int flag = evsel__intval(evsel, sample, "flags"); | |
668 | u64 key; | |
669 | int ret; | |
670 | ||
671 | ret = get_key_by_aggr_mode_simple(&key, addr, sample->tid); | |
672 | if (ret < 0) | |
673 | return ret; | |
7c3bcbdf | 674 | |
f9c695a2 | 675 | ls = lock_stat_findnew(key, name, 0); |
33d6aef5 | 676 | if (!ls) |
b33492ad | 677 | return -ENOMEM; |
9b5e350c | 678 | |
01d95524 | 679 | ts = thread_stat_findnew(sample->tid); |
33d6aef5 | 680 | if (!ts) |
b33492ad | 681 | return -ENOMEM; |
33d6aef5 | 682 | |
746f16ec | 683 | seq = get_seq(ts, addr); |
33d6aef5 | 684 | if (!seq) |
b33492ad | 685 | return -ENOMEM; |
9b5e350c | 686 | |
e4cef1f6 HM |
687 | switch (seq->state) { |
688 | case SEQ_STATE_UNINITIALIZED: | |
689 | case SEQ_STATE_RELEASED: | |
746f16ec | 690 | if (!flag) { |
e4cef1f6 HM |
691 | seq->state = SEQ_STATE_ACQUIRING; |
692 | } else { | |
746f16ec | 693 | if (flag & TRY_LOCK) |
e4cef1f6 | 694 | ls->nr_trylock++; |
746f16ec | 695 | if (flag & READ_LOCK) |
e4cef1f6 HM |
696 | ls->nr_readlock++; |
697 | seq->state = SEQ_STATE_READ_ACQUIRED; | |
698 | seq->read_count = 1; | |
699 | ls->nr_acquired++; | |
700 | } | |
701 | break; | |
702 | case SEQ_STATE_READ_ACQUIRED: | |
746f16ec | 703 | if (flag & READ_LOCK) { |
e4cef1f6 HM |
704 | seq->read_count++; |
705 | ls->nr_acquired++; | |
706 | goto end; | |
707 | } else { | |
708 | goto broken; | |
709 | } | |
9b5e350c | 710 | break; |
e4cef1f6 HM |
711 | case SEQ_STATE_ACQUIRED: |
712 | case SEQ_STATE_ACQUIRING: | |
713 | case SEQ_STATE_CONTENDED: | |
714 | broken: | |
79d9333b NK |
715 | /* broken lock sequence */ |
716 | if (!ls->broken) { | |
717 | ls->broken = 1; | |
718 | bad_hist[BROKEN_ACQUIRE]++; | |
719 | } | |
e56fbc9d | 720 | list_del_init(&seq->list); |
e4cef1f6 HM |
721 | free(seq); |
722 | goto end; | |
9b5e350c | 723 | default: |
e4cef1f6 | 724 | BUG_ON("Unknown state of lock sequence found!\n"); |
9b5e350c HM |
725 | break; |
726 | } | |
727 | ||
e4cef1f6 | 728 | ls->nr_acquire++; |
01d95524 | 729 | seq->prev_event_time = sample->time; |
e4cef1f6 | 730 | end: |
33d6aef5 | 731 | return 0; |
9b5e350c HM |
732 | } |
733 | ||
32dcd021 | 734 | static int report_lock_acquired_event(struct evsel *evsel, |
746f16ec | 735 | struct perf_sample *sample) |
9b5e350c | 736 | { |
e4cef1f6 HM |
737 | struct lock_stat *ls; |
738 | struct thread_stat *ts; | |
739 | struct lock_seq_stat *seq; | |
740 | u64 contended_term; | |
efc0cdc9 | 741 | const char *name = evsel__strval(evsel, sample, "name"); |
e1c3177b | 742 | u64 addr = evsel__intval(evsel, sample, "lockdep_addr"); |
f9c695a2 | 743 | u64 key; |
0f405f87 | 744 | int ret; |
9b5e350c | 745 | |
0f405f87 SX |
746 | ret = get_key_by_aggr_mode_simple(&key, addr, sample->tid); |
747 | if (ret < 0) | |
748 | return ret; | |
7c3bcbdf | 749 | |
f9c695a2 | 750 | ls = lock_stat_findnew(key, name, 0); |
33d6aef5 | 751 | if (!ls) |
b33492ad | 752 | return -ENOMEM; |
e4cef1f6 | 753 | |
01d95524 | 754 | ts = thread_stat_findnew(sample->tid); |
33d6aef5 | 755 | if (!ts) |
b33492ad | 756 | return -ENOMEM; |
33d6aef5 | 757 | |
746f16ec | 758 | seq = get_seq(ts, addr); |
33d6aef5 | 759 | if (!seq) |
b33492ad | 760 | return -ENOMEM; |
9b5e350c | 761 | |
e4cef1f6 HM |
762 | switch (seq->state) { |
763 | case SEQ_STATE_UNINITIALIZED: | |
764 | /* orphan event, do nothing */ | |
33d6aef5 | 765 | return 0; |
e4cef1f6 | 766 | case SEQ_STATE_ACQUIRING: |
9b5e350c | 767 | break; |
e4cef1f6 | 768 | case SEQ_STATE_CONTENDED: |
746f16ec | 769 | contended_term = sample->time - seq->prev_event_time; |
e4cef1f6 | 770 | ls->wait_time_total += contended_term; |
e4cef1f6 HM |
771 | if (contended_term < ls->wait_time_min) |
772 | ls->wait_time_min = contended_term; | |
90c0e5fc | 773 | if (ls->wait_time_max < contended_term) |
e4cef1f6 | 774 | ls->wait_time_max = contended_term; |
9b5e350c | 775 | break; |
e4cef1f6 HM |
776 | case SEQ_STATE_RELEASED: |
777 | case SEQ_STATE_ACQUIRED: | |
778 | case SEQ_STATE_READ_ACQUIRED: | |
79d9333b NK |
779 | /* broken lock sequence */ |
780 | if (!ls->broken) { | |
781 | ls->broken = 1; | |
782 | bad_hist[BROKEN_ACQUIRED]++; | |
783 | } | |
e56fbc9d | 784 | list_del_init(&seq->list); |
e4cef1f6 HM |
785 | free(seq); |
786 | goto end; | |
9b5e350c | 787 | default: |
e4cef1f6 | 788 | BUG_ON("Unknown state of lock sequence found!\n"); |
9b5e350c HM |
789 | break; |
790 | } | |
791 | ||
e4cef1f6 HM |
792 | seq->state = SEQ_STATE_ACQUIRED; |
793 | ls->nr_acquired++; | |
f37376cd | 794 | ls->avg_wait_time = ls->nr_contended ? ls->wait_time_total/ls->nr_contended : 0; |
746f16ec | 795 | seq->prev_event_time = sample->time; |
e4cef1f6 | 796 | end: |
33d6aef5 | 797 | return 0; |
9b5e350c HM |
798 | } |
799 | ||
32dcd021 | 800 | static int report_lock_contended_event(struct evsel *evsel, |
746f16ec | 801 | struct perf_sample *sample) |
9b5e350c | 802 | { |
e4cef1f6 HM |
803 | struct lock_stat *ls; |
804 | struct thread_stat *ts; | |
805 | struct lock_seq_stat *seq; | |
efc0cdc9 | 806 | const char *name = evsel__strval(evsel, sample, "name"); |
e1c3177b | 807 | u64 addr = evsel__intval(evsel, sample, "lockdep_addr"); |
f9c695a2 | 808 | u64 key; |
0f405f87 | 809 | int ret; |
e4cef1f6 | 810 | |
0f405f87 SX |
811 | ret = get_key_by_aggr_mode_simple(&key, addr, sample->tid); |
812 | if (ret < 0) | |
813 | return ret; | |
7c3bcbdf | 814 | |
f9c695a2 | 815 | ls = lock_stat_findnew(key, name, 0); |
33d6aef5 | 816 | if (!ls) |
b33492ad | 817 | return -ENOMEM; |
9b5e350c | 818 | |
01d95524 | 819 | ts = thread_stat_findnew(sample->tid); |
33d6aef5 | 820 | if (!ts) |
b33492ad | 821 | return -ENOMEM; |
33d6aef5 | 822 | |
746f16ec | 823 | seq = get_seq(ts, addr); |
33d6aef5 | 824 | if (!seq) |
b33492ad | 825 | return -ENOMEM; |
9b5e350c | 826 | |
e4cef1f6 HM |
827 | switch (seq->state) { |
828 | case SEQ_STATE_UNINITIALIZED: | |
829 | /* orphan event, do nothing */ | |
33d6aef5 | 830 | return 0; |
e4cef1f6 | 831 | case SEQ_STATE_ACQUIRING: |
9b5e350c | 832 | break; |
e4cef1f6 HM |
833 | case SEQ_STATE_RELEASED: |
834 | case SEQ_STATE_ACQUIRED: | |
835 | case SEQ_STATE_READ_ACQUIRED: | |
836 | case SEQ_STATE_CONTENDED: | |
79d9333b NK |
837 | /* broken lock sequence */ |
838 | if (!ls->broken) { | |
839 | ls->broken = 1; | |
840 | bad_hist[BROKEN_CONTENDED]++; | |
841 | } | |
e56fbc9d | 842 | list_del_init(&seq->list); |
e4cef1f6 HM |
843 | free(seq); |
844 | goto end; | |
9b5e350c | 845 | default: |
e4cef1f6 | 846 | BUG_ON("Unknown state of lock sequence found!\n"); |
9b5e350c HM |
847 | break; |
848 | } | |
849 | ||
e4cef1f6 HM |
850 | seq->state = SEQ_STATE_CONTENDED; |
851 | ls->nr_contended++; | |
f37376cd | 852 | ls->avg_wait_time = ls->wait_time_total/ls->nr_contended; |
01d95524 | 853 | seq->prev_event_time = sample->time; |
e4cef1f6 | 854 | end: |
33d6aef5 | 855 | return 0; |
9b5e350c HM |
856 | } |
857 | ||
32dcd021 | 858 | static int report_lock_release_event(struct evsel *evsel, |
746f16ec | 859 | struct perf_sample *sample) |
9b5e350c | 860 | { |
e4cef1f6 HM |
861 | struct lock_stat *ls; |
862 | struct thread_stat *ts; | |
863 | struct lock_seq_stat *seq; | |
efc0cdc9 | 864 | const char *name = evsel__strval(evsel, sample, "name"); |
e1c3177b | 865 | u64 addr = evsel__intval(evsel, sample, "lockdep_addr"); |
f9c695a2 | 866 | u64 key; |
0f405f87 | 867 | int ret; |
746f16ec | 868 | |
0f405f87 SX |
869 | ret = get_key_by_aggr_mode_simple(&key, addr, sample->tid); |
870 | if (ret < 0) | |
871 | return ret; | |
7c3bcbdf | 872 | |
f9c695a2 | 873 | ls = lock_stat_findnew(key, name, 0); |
33d6aef5 | 874 | if (!ls) |
b33492ad | 875 | return -ENOMEM; |
9b5e350c | 876 | |
01d95524 | 877 | ts = thread_stat_findnew(sample->tid); |
33d6aef5 | 878 | if (!ts) |
b33492ad | 879 | return -ENOMEM; |
33d6aef5 | 880 | |
746f16ec | 881 | seq = get_seq(ts, addr); |
33d6aef5 | 882 | if (!seq) |
b33492ad | 883 | return -ENOMEM; |
9b5e350c | 884 | |
e4cef1f6 HM |
885 | switch (seq->state) { |
886 | case SEQ_STATE_UNINITIALIZED: | |
887 | goto end; | |
e4cef1f6 HM |
888 | case SEQ_STATE_ACQUIRED: |
889 | break; | |
890 | case SEQ_STATE_READ_ACQUIRED: | |
891 | seq->read_count--; | |
892 | BUG_ON(seq->read_count < 0); | |
b0e5a05c | 893 | if (seq->read_count) { |
e4cef1f6 | 894 | ls->nr_release++; |
9b5e350c HM |
895 | goto end; |
896 | } | |
e4cef1f6 HM |
897 | break; |
898 | case SEQ_STATE_ACQUIRING: | |
899 | case SEQ_STATE_CONTENDED: | |
900 | case SEQ_STATE_RELEASED: | |
79d9333b NK |
901 | /* broken lock sequence */ |
902 | if (!ls->broken) { | |
903 | ls->broken = 1; | |
904 | bad_hist[BROKEN_RELEASE]++; | |
905 | } | |
e4cef1f6 | 906 | goto free_seq; |
9b5e350c | 907 | default: |
e4cef1f6 | 908 | BUG_ON("Unknown state of lock sequence found!\n"); |
9b5e350c HM |
909 | break; |
910 | } | |
911 | ||
e4cef1f6 HM |
912 | ls->nr_release++; |
913 | free_seq: | |
e56fbc9d | 914 | list_del_init(&seq->list); |
e4cef1f6 | 915 | free(seq); |
9b5e350c | 916 | end: |
33d6aef5 | 917 | return 0; |
9b5e350c HM |
918 | } |
919 | ||
637522ce NK |
920 | static int get_symbol_name_offset(struct map *map, struct symbol *sym, u64 ip, |
921 | char *buf, int size) | |
922 | { | |
923 | u64 offset; | |
924 | ||
925 | if (map == NULL || sym == NULL) { | |
926 | buf[0] = '\0'; | |
927 | return 0; | |
928 | } | |
929 | ||
78a1f7cd | 930 | offset = map__map_ip(map, ip) - sym->start; |
637522ce NK |
931 | |
932 | if (offset) | |
933 | return scnprintf(buf, size, "%s+%#lx", sym->name, offset); | |
934 | else | |
935 | return strlcpy(buf, sym->name, size); | |
936 | } | |
0d2997f7 NK |
937 | static int lock_contention_caller(struct evsel *evsel, struct perf_sample *sample, |
938 | char *buf, int size) | |
939 | { | |
940 | struct thread *thread; | |
8ab12a20 | 941 | struct callchain_cursor *cursor; |
77d54a2c | 942 | struct machine *machine = &session->machines.host; |
0d2997f7 NK |
943 | struct symbol *sym; |
944 | int skip = 0; | |
945 | int ret; | |
946 | ||
947 | /* lock names will be replaced to task name later */ | |
948 | if (show_thread_stats) | |
949 | return -1; | |
950 | ||
77d54a2c | 951 | thread = machine__findnew_thread(machine, -1, sample->pid); |
0d2997f7 NK |
952 | if (thread == NULL) |
953 | return -1; | |
954 | ||
8ab12a20 IR |
955 | cursor = get_tls_callchain_cursor(); |
956 | ||
0d2997f7 NK |
957 | /* use caller function name from the callchain */ |
958 | ret = thread__resolve_callchain(thread, cursor, evsel, sample, | |
96532a83 | 959 | NULL, NULL, max_stack_depth); |
0d2997f7 NK |
960 | if (ret != 0) { |
961 | thread__put(thread); | |
962 | return -1; | |
963 | } | |
964 | ||
965 | callchain_cursor_commit(cursor); | |
966 | thread__put(thread); | |
967 | ||
968 | while (true) { | |
969 | struct callchain_cursor_node *node; | |
970 | ||
971 | node = callchain_cursor_current(cursor); | |
972 | if (node == NULL) | |
973 | break; | |
974 | ||
975 | /* skip first few entries - for lock functions */ | |
96532a83 | 976 | if (++skip <= stack_skip) |
0d2997f7 NK |
977 | goto next; |
978 | ||
979 | sym = node->ms.sym; | |
cc2367ee | 980 | if (sym && !machine__is_lock_function(machine, node->ip)) { |
637522ce NK |
981 | get_symbol_name_offset(node->ms.map, sym, node->ip, |
982 | buf, size); | |
0d2997f7 NK |
983 | return 0; |
984 | } | |
985 | ||
986 | next: | |
987 | callchain_cursor_advance(cursor); | |
988 | } | |
989 | return -1; | |
990 | } | |
991 | ||
528b9cab NK |
992 | static u64 callchain_id(struct evsel *evsel, struct perf_sample *sample) |
993 | { | |
8ab12a20 | 994 | struct callchain_cursor *cursor; |
77d54a2c | 995 | struct machine *machine = &session->machines.host; |
528b9cab NK |
996 | struct thread *thread; |
997 | u64 hash = 0; | |
998 | int skip = 0; | |
999 | int ret; | |
1000 | ||
77d54a2c | 1001 | thread = machine__findnew_thread(machine, -1, sample->pid); |
528b9cab NK |
1002 | if (thread == NULL) |
1003 | return -1; | |
1004 | ||
8ab12a20 | 1005 | cursor = get_tls_callchain_cursor(); |
528b9cab NK |
1006 | /* use caller function name from the callchain */ |
1007 | ret = thread__resolve_callchain(thread, cursor, evsel, sample, | |
96532a83 | 1008 | NULL, NULL, max_stack_depth); |
528b9cab NK |
1009 | thread__put(thread); |
1010 | ||
1011 | if (ret != 0) | |
1012 | return -1; | |
1013 | ||
1014 | callchain_cursor_commit(cursor); | |
1015 | ||
1016 | while (true) { | |
1017 | struct callchain_cursor_node *node; | |
1018 | ||
1019 | node = callchain_cursor_current(cursor); | |
1020 | if (node == NULL) | |
1021 | break; | |
1022 | ||
1023 | /* skip first few entries - for lock functions */ | |
96532a83 | 1024 | if (++skip <= stack_skip) |
528b9cab NK |
1025 | goto next; |
1026 | ||
cc2367ee | 1027 | if (node->ms.sym && machine__is_lock_function(machine, node->ip)) |
528b9cab NK |
1028 | goto next; |
1029 | ||
1030 | hash ^= hash_long((unsigned long)node->ip, 64); | |
1031 | ||
1032 | next: | |
1033 | callchain_cursor_advance(cursor); | |
1034 | } | |
1035 | return hash; | |
1036 | } | |
1037 | ||
a6eaf966 NK |
1038 | static u64 *get_callstack(struct perf_sample *sample, int max_stack) |
1039 | { | |
1040 | u64 *callstack; | |
1041 | u64 i; | |
1042 | int c; | |
1043 | ||
1044 | callstack = calloc(max_stack, sizeof(*callstack)); | |
1045 | if (callstack == NULL) | |
1046 | return NULL; | |
1047 | ||
1048 | for (i = 0, c = 0; i < sample->callchain->nr && c < max_stack; i++) { | |
1049 | u64 ip = sample->callchain->ips[i]; | |
1050 | ||
1051 | if (ip >= PERF_CONTEXT_MAX) | |
1052 | continue; | |
1053 | ||
1054 | callstack[c++] = ip; | |
1055 | } | |
1056 | return callstack; | |
1057 | } | |
1058 | ||
3ae03f26 NK |
1059 | static int report_lock_contention_begin_event(struct evsel *evsel, |
1060 | struct perf_sample *sample) | |
1061 | { | |
1062 | struct lock_stat *ls; | |
1063 | struct thread_stat *ts; | |
1064 | struct lock_seq_stat *seq; | |
1065 | u64 addr = evsel__intval(evsel, sample, "lock_addr"); | |
b4a7eff9 | 1066 | unsigned int flags = evsel__intval(evsel, sample, "flags"); |
f9c695a2 | 1067 | u64 key; |
b4a7eff9 | 1068 | int i, ret; |
511e19b9 NK |
1069 | static bool kmap_loaded; |
1070 | struct machine *machine = &session->machines.host; | |
1071 | struct map *kmap; | |
1072 | struct symbol *sym; | |
3ae03f26 | 1073 | |
0f405f87 SX |
1074 | ret = get_key_by_aggr_mode(&key, addr, evsel, sample); |
1075 | if (ret < 0) | |
1076 | return ret; | |
3ae03f26 | 1077 | |
511e19b9 NK |
1078 | if (!kmap_loaded) { |
1079 | unsigned long *addrs; | |
1080 | ||
1081 | /* make sure it loads the kernel map to find lock symbols */ | |
1082 | map__load(machine__kernel_map(machine)); | |
1083 | kmap_loaded = true; | |
1084 | ||
1085 | /* convert (kernel) symbols to addresses */ | |
1086 | for (i = 0; i < filters.nr_syms; i++) { | |
1087 | sym = machine__find_kernel_symbol_by_name(machine, | |
1088 | filters.syms[i], | |
1089 | &kmap); | |
1090 | if (sym == NULL) { | |
1091 | pr_warning("ignore unknown symbol: %s\n", | |
1092 | filters.syms[i]); | |
1093 | continue; | |
1094 | } | |
1095 | ||
1096 | addrs = realloc(filters.addrs, | |
1097 | (filters.nr_addrs + 1) * sizeof(*addrs)); | |
1098 | if (addrs == NULL) { | |
1099 | pr_warning("memory allocation failure\n"); | |
1100 | return -ENOMEM; | |
1101 | } | |
1102 | ||
78a1f7cd | 1103 | addrs[filters.nr_addrs++] = map__unmap_ip(kmap, sym->start); |
511e19b9 NK |
1104 | filters.addrs = addrs; |
1105 | } | |
1106 | } | |
1107 | ||
f9c695a2 | 1108 | ls = lock_stat_find(key); |
0d2997f7 NK |
1109 | if (!ls) { |
1110 | char buf[128]; | |
688d2e8d | 1111 | const char *name = ""; |
688d2e8d NK |
1112 | |
1113 | switch (aggr_mode) { | |
1114 | case LOCK_AGGR_ADDR: | |
688d2e8d NK |
1115 | sym = machine__find_kernel_symbol(machine, key, &kmap); |
1116 | if (sym) | |
1117 | name = sym->name; | |
1118 | break; | |
1119 | case LOCK_AGGR_CALLER: | |
1120 | name = buf; | |
1121 | if (lock_contention_caller(evsel, sample, buf, sizeof(buf)) < 0) | |
1122 | name = "Unknown"; | |
1123 | break; | |
4d1792d0 | 1124 | case LOCK_AGGR_CGROUP: |
688d2e8d NK |
1125 | case LOCK_AGGR_TASK: |
1126 | default: | |
1127 | break; | |
1128 | } | |
0d2997f7 | 1129 | |
688d2e8d | 1130 | ls = lock_stat_findnew(key, name, flags); |
0d2997f7 NK |
1131 | if (!ls) |
1132 | return -ENOMEM; | |
1133 | } | |
3ae03f26 | 1134 | |
b4a7eff9 NK |
1135 | if (filters.nr_types) { |
1136 | bool found = false; | |
1137 | ||
1138 | for (i = 0; i < filters.nr_types; i++) { | |
1139 | if (flags == filters.types[i]) { | |
1140 | found = true; | |
1141 | break; | |
1142 | } | |
1143 | } | |
1144 | ||
1145 | if (!found) | |
1146 | return 0; | |
1147 | } | |
1148 | ||
511e19b9 NK |
1149 | if (filters.nr_addrs) { |
1150 | bool found = false; | |
1151 | ||
1152 | for (i = 0; i < filters.nr_addrs; i++) { | |
1153 | if (addr == filters.addrs[i]) { | |
1154 | found = true; | |
1155 | break; | |
1156 | } | |
1157 | } | |
1158 | ||
1159 | if (!found) | |
1160 | return 0; | |
1161 | } | |
1162 | ||
ebab2916 NK |
1163 | if (needs_callstack()) { |
1164 | u64 *callstack = get_callstack(sample, max_stack_depth); | |
1165 | if (callstack == NULL) | |
1166 | return -ENOMEM; | |
1167 | ||
1168 | if (!match_callstack_filter(machine, callstack)) { | |
1169 | free(callstack); | |
1170 | return 0; | |
1171 | } | |
1172 | ||
1173 | if (ls->callstack == NULL) | |
1174 | ls->callstack = callstack; | |
1175 | else | |
1176 | free(callstack); | |
1177 | } | |
1178 | ||
3ae03f26 NK |
1179 | ts = thread_stat_findnew(sample->tid); |
1180 | if (!ts) | |
1181 | return -ENOMEM; | |
1182 | ||
1183 | seq = get_seq(ts, addr); | |
1184 | if (!seq) | |
1185 | return -ENOMEM; | |
1186 | ||
1187 | switch (seq->state) { | |
1188 | case SEQ_STATE_UNINITIALIZED: | |
1189 | case SEQ_STATE_ACQUIRED: | |
1190 | break; | |
1191 | case SEQ_STATE_CONTENDED: | |
1192 | /* | |
1193 | * It can have nested contention begin with mutex spinning, | |
1194 | * then we would use the original contention begin event and | |
1195 | * ignore the second one. | |
1196 | */ | |
1197 | goto end; | |
1198 | case SEQ_STATE_ACQUIRING: | |
1199 | case SEQ_STATE_READ_ACQUIRED: | |
1200 | case SEQ_STATE_RELEASED: | |
1201 | /* broken lock sequence */ | |
1202 | if (!ls->broken) { | |
1203 | ls->broken = 1; | |
1204 | bad_hist[BROKEN_CONTENDED]++; | |
1205 | } | |
1206 | list_del_init(&seq->list); | |
1207 | free(seq); | |
1208 | goto end; | |
1209 | default: | |
1210 | BUG_ON("Unknown state of lock sequence found!\n"); | |
1211 | break; | |
1212 | } | |
1213 | ||
1214 | if (seq->state != SEQ_STATE_CONTENDED) { | |
1215 | seq->state = SEQ_STATE_CONTENDED; | |
1216 | seq->prev_event_time = sample->time; | |
1217 | ls->nr_contended++; | |
1218 | } | |
1219 | end: | |
1220 | return 0; | |
1221 | } | |
1222 | ||
1223 | static int report_lock_contention_end_event(struct evsel *evsel, | |
1224 | struct perf_sample *sample) | |
1225 | { | |
1226 | struct lock_stat *ls; | |
1227 | struct thread_stat *ts; | |
1228 | struct lock_seq_stat *seq; | |
1229 | u64 contended_term; | |
1230 | u64 addr = evsel__intval(evsel, sample, "lock_addr"); | |
f9c695a2 | 1231 | u64 key; |
0f405f87 | 1232 | int ret; |
3ae03f26 | 1233 | |
0f405f87 SX |
1234 | ret = get_key_by_aggr_mode(&key, addr, evsel, sample); |
1235 | if (ret < 0) | |
1236 | return ret; | |
3ae03f26 | 1237 | |
f9c695a2 | 1238 | ls = lock_stat_find(key); |
3ae03f26 NK |
1239 | if (!ls) |
1240 | return 0; | |
1241 | ||
1242 | ts = thread_stat_find(sample->tid); | |
1243 | if (!ts) | |
1244 | return 0; | |
1245 | ||
1246 | seq = get_seq(ts, addr); | |
1247 | if (!seq) | |
1248 | return -ENOMEM; | |
1249 | ||
1250 | switch (seq->state) { | |
1251 | case SEQ_STATE_UNINITIALIZED: | |
1252 | goto end; | |
1253 | case SEQ_STATE_CONTENDED: | |
1254 | contended_term = sample->time - seq->prev_event_time; | |
1255 | ls->wait_time_total += contended_term; | |
1256 | if (contended_term < ls->wait_time_min) | |
1257 | ls->wait_time_min = contended_term; | |
1258 | if (ls->wait_time_max < contended_term) | |
1259 | ls->wait_time_max = contended_term; | |
1260 | break; | |
1261 | case SEQ_STATE_ACQUIRING: | |
1262 | case SEQ_STATE_ACQUIRED: | |
1263 | case SEQ_STATE_READ_ACQUIRED: | |
1264 | case SEQ_STATE_RELEASED: | |
1265 | /* broken lock sequence */ | |
1266 | if (!ls->broken) { | |
1267 | ls->broken = 1; | |
1268 | bad_hist[BROKEN_ACQUIRED]++; | |
1269 | } | |
1270 | list_del_init(&seq->list); | |
1271 | free(seq); | |
1272 | goto end; | |
1273 | default: | |
1274 | BUG_ON("Unknown state of lock sequence found!\n"); | |
1275 | break; | |
1276 | } | |
1277 | ||
1278 | seq->state = SEQ_STATE_ACQUIRED; | |
1279 | ls->nr_acquired++; | |
1280 | ls->avg_wait_time = ls->wait_time_total/ls->nr_acquired; | |
1281 | end: | |
1282 | return 0; | |
1283 | } | |
1284 | ||
9b5e350c HM |
1285 | /* lock oriented handlers */ |
1286 | /* TODO: handlers for CPU oriented, thread oriented */ | |
59f411b6 IM |
1287 | static struct trace_lock_handler report_lock_ops = { |
1288 | .acquire_event = report_lock_acquire_event, | |
1289 | .acquired_event = report_lock_acquired_event, | |
1290 | .contended_event = report_lock_contended_event, | |
1291 | .release_event = report_lock_release_event, | |
3ae03f26 NK |
1292 | .contention_begin_event = report_lock_contention_begin_event, |
1293 | .contention_end_event = report_lock_contention_end_event, | |
9b5e350c HM |
1294 | }; |
1295 | ||
528b9cab NK |
1296 | static struct trace_lock_handler contention_lock_ops = { |
1297 | .contention_begin_event = report_lock_contention_begin_event, | |
1298 | .contention_end_event = report_lock_contention_end_event, | |
1299 | }; | |
1300 | ||
1301 | ||
9b5e350c HM |
1302 | static struct trace_lock_handler *trace_handler; |
1303 | ||
3d655813 | 1304 | static int evsel__process_lock_acquire(struct evsel *evsel, struct perf_sample *sample) |
9b5e350c | 1305 | { |
59f411b6 | 1306 | if (trace_handler->acquire_event) |
746f16ec ACM |
1307 | return trace_handler->acquire_event(evsel, sample); |
1308 | return 0; | |
9b5e350c HM |
1309 | } |
1310 | ||
3d655813 | 1311 | static int evsel__process_lock_acquired(struct evsel *evsel, struct perf_sample *sample) |
9b5e350c | 1312 | { |
33d6aef5 | 1313 | if (trace_handler->acquired_event) |
746f16ec ACM |
1314 | return trace_handler->acquired_event(evsel, sample); |
1315 | return 0; | |
9b5e350c HM |
1316 | } |
1317 | ||
3d655813 | 1318 | static int evsel__process_lock_contended(struct evsel *evsel, struct perf_sample *sample) |
9b5e350c | 1319 | { |
33d6aef5 | 1320 | if (trace_handler->contended_event) |
746f16ec ACM |
1321 | return trace_handler->contended_event(evsel, sample); |
1322 | return 0; | |
9b5e350c HM |
1323 | } |
1324 | ||
3d655813 | 1325 | static int evsel__process_lock_release(struct evsel *evsel, struct perf_sample *sample) |
9b5e350c | 1326 | { |
33d6aef5 | 1327 | if (trace_handler->release_event) |
746f16ec ACM |
1328 | return trace_handler->release_event(evsel, sample); |
1329 | return 0; | |
9b5e350c HM |
1330 | } |
1331 | ||
166a9764 NK |
1332 | static int evsel__process_contention_begin(struct evsel *evsel, struct perf_sample *sample) |
1333 | { | |
1334 | if (trace_handler->contention_begin_event) | |
1335 | return trace_handler->contention_begin_event(evsel, sample); | |
1336 | return 0; | |
1337 | } | |
1338 | ||
1339 | static int evsel__process_contention_end(struct evsel *evsel, struct perf_sample *sample) | |
1340 | { | |
1341 | if (trace_handler->contention_end_event) | |
1342 | return trace_handler->contention_end_event(evsel, sample); | |
1343 | return 0; | |
1344 | } | |
1345 | ||
10350ec3 FW |
1346 | static void print_bad_events(int bad, int total) |
1347 | { | |
1348 | /* Output for debug, this have to be removed */ | |
1349 | int i; | |
9565c918 | 1350 | int broken = 0; |
10350ec3 FW |
1351 | const char *name[4] = |
1352 | { "acquire", "acquired", "contended", "release" }; | |
1353 | ||
9565c918 NK |
1354 | for (i = 0; i < BROKEN_MAX; i++) |
1355 | broken += bad_hist[i]; | |
1356 | ||
35bf007e | 1357 | if (quiet || total == 0 || (broken == 0 && verbose <= 0)) |
9565c918 NK |
1358 | return; |
1359 | ||
f6027053 NK |
1360 | fprintf(lock_output, "\n=== output for debug ===\n\n"); |
1361 | fprintf(lock_output, "bad: %d, total: %d\n", bad, total); | |
1362 | fprintf(lock_output, "bad rate: %.2f %%\n", (double)bad / (double)total * 100); | |
1363 | fprintf(lock_output, "histogram of events caused bad sequence\n"); | |
10350ec3 | 1364 | for (i = 0; i < BROKEN_MAX; i++) |
f6027053 | 1365 | fprintf(lock_output, " %10s: %d\n", name[i], bad_hist[i]); |
10350ec3 FW |
1366 | } |
1367 | ||
9b5e350c HM |
1368 | /* TODO: various way to print, coloring, nano or milli sec */ |
1369 | static void print_result(void) | |
1370 | { | |
1371 | struct lock_stat *st; | |
64999e44 | 1372 | struct lock_key *key; |
9b5e350c | 1373 | char cut_name[20]; |
6282a1f4 | 1374 | int bad, total, printed; |
9b5e350c | 1375 | |
6bbc4820 | 1376 | if (!quiet) { |
f6027053 | 1377 | fprintf(lock_output, "%20s ", "Name"); |
6bbc4820 | 1378 | list_for_each_entry(key, &lock_keys, list) |
f6027053 NK |
1379 | fprintf(lock_output, "%*s ", key->len, key->header); |
1380 | fprintf(lock_output, "\n\n"); | |
6bbc4820 | 1381 | } |
9b5e350c | 1382 | |
6282a1f4 | 1383 | bad = total = printed = 0; |
9b5e350c | 1384 | while ((st = pop_from_result())) { |
e4cef1f6 | 1385 | total++; |
79d9333b | 1386 | if (st->broken) |
e4cef1f6 | 1387 | bad++; |
79d9333b | 1388 | if (!st->nr_acquired) |
e4cef1f6 | 1389 | continue; |
79d9333b | 1390 | |
9b5e350c HM |
1391 | bzero(cut_name, 20); |
1392 | ||
ba8a56c7 | 1393 | if (strlen(st->name) < 20) { |
9b5e350c | 1394 | /* output raw name */ |
7c3bcbdf NK |
1395 | const char *name = st->name; |
1396 | ||
1397 | if (show_thread_stats) { | |
1398 | struct thread *t; | |
1399 | ||
1400 | /* st->addr contains tid of thread */ | |
1401 | t = perf_session__findnew(session, st->addr); | |
1402 | name = thread__comm_str(t); | |
1403 | } | |
1404 | ||
f6027053 | 1405 | fprintf(lock_output, "%20s ", name); |
9b5e350c HM |
1406 | } else { |
1407 | strncpy(cut_name, st->name, 16); | |
1408 | cut_name[16] = '.'; | |
1409 | cut_name[17] = '.'; | |
1410 | cut_name[18] = '.'; | |
1411 | cut_name[19] = '\0'; | |
1412 | /* cut off name for saving output style */ | |
f6027053 | 1413 | fprintf(lock_output, "%20s ", cut_name); |
9b5e350c HM |
1414 | } |
1415 | ||
64999e44 NK |
1416 | list_for_each_entry(key, &lock_keys, list) { |
1417 | key->print(key, st); | |
f6027053 | 1418 | fprintf(lock_output, " "); |
64999e44 | 1419 | } |
f6027053 | 1420 | fprintf(lock_output, "\n"); |
6282a1f4 NK |
1421 | |
1422 | if (++printed >= print_nr_entries) | |
1423 | break; | |
9b5e350c | 1424 | } |
e4cef1f6 | 1425 | |
10350ec3 | 1426 | print_bad_events(bad, total); |
9b5e350c HM |
1427 | } |
1428 | ||
8035458f | 1429 | static bool info_threads, info_map; |
26242d85 HM |
1430 | |
1431 | static void dump_threads(void) | |
1432 | { | |
1433 | struct thread_stat *st; | |
1434 | struct rb_node *node; | |
1435 | struct thread *t; | |
1436 | ||
f6027053 | 1437 | fprintf(lock_output, "%10s: comm\n", "Thread ID"); |
26242d85 HM |
1438 | |
1439 | node = rb_first(&thread_stats); | |
1440 | while (node) { | |
1441 | st = container_of(node, struct thread_stat, rb); | |
1442 | t = perf_session__findnew(session, st->tid); | |
f6027053 | 1443 | fprintf(lock_output, "%10d: %s\n", st->tid, thread__comm_str(t)); |
26242d85 | 1444 | node = rb_next(node); |
b91fc39f | 1445 | thread__put(t); |
8284bbea | 1446 | } |
26242d85 HM |
1447 | } |
1448 | ||
f4cf2d75 NK |
1449 | static int compare_maps(struct lock_stat *a, struct lock_stat *b) |
1450 | { | |
1451 | int ret; | |
1452 | ||
1453 | if (a->name && b->name) | |
1454 | ret = strcmp(a->name, b->name); | |
1455 | else | |
1456 | ret = !!a->name - !!b->name; | |
1457 | ||
1458 | if (!ret) | |
1459 | return a->addr < b->addr; | |
1460 | else | |
1461 | return ret < 0; | |
1462 | } | |
1463 | ||
9b5e350c HM |
1464 | static void dump_map(void) |
1465 | { | |
1466 | unsigned int i; | |
1467 | struct lock_stat *st; | |
1468 | ||
f6027053 | 1469 | fprintf(lock_output, "Address of instance: name of class\n"); |
9b5e350c | 1470 | for (i = 0; i < LOCKHASH_SIZE; i++) { |
7672d00a | 1471 | hlist_for_each_entry(st, &lockhash_table[i], hash_entry) { |
f4cf2d75 | 1472 | insert_to_result(st, compare_maps); |
9b5e350c HM |
1473 | } |
1474 | } | |
f4cf2d75 NK |
1475 | |
1476 | while ((st = pop_from_result())) | |
f6027053 | 1477 | fprintf(lock_output, " %#llx: %s\n", (unsigned long long)st->addr, st->name); |
9b5e350c HM |
1478 | } |
1479 | ||
33d6aef5 | 1480 | static int dump_info(void) |
26242d85 | 1481 | { |
33d6aef5 DA |
1482 | int rc = 0; |
1483 | ||
26242d85 HM |
1484 | if (info_threads) |
1485 | dump_threads(); | |
1486 | else if (info_map) | |
1487 | dump_map(); | |
33d6aef5 DA |
1488 | else { |
1489 | rc = -1; | |
1490 | pr_err("Unknown type of information\n"); | |
1491 | } | |
1492 | ||
1493 | return rc; | |
26242d85 HM |
1494 | } |
1495 | ||
30b331d2 NK |
1496 | static const struct evsel_str_handler lock_tracepoints[] = { |
1497 | { "lock:lock_acquire", evsel__process_lock_acquire, }, /* CONFIG_LOCKDEP */ | |
1498 | { "lock:lock_acquired", evsel__process_lock_acquired, }, /* CONFIG_LOCKDEP, CONFIG_LOCK_STAT */ | |
1499 | { "lock:lock_contended", evsel__process_lock_contended, }, /* CONFIG_LOCKDEP, CONFIG_LOCK_STAT */ | |
1500 | { "lock:lock_release", evsel__process_lock_release, }, /* CONFIG_LOCKDEP */ | |
1501 | }; | |
1502 | ||
1503 | static const struct evsel_str_handler contention_tracepoints[] = { | |
1504 | { "lock:contention_begin", evsel__process_contention_begin, }, | |
1505 | { "lock:contention_end", evsel__process_contention_end, }, | |
1506 | }; | |
1507 | ||
1508 | static int process_event_update(struct perf_tool *tool, | |
1509 | union perf_event *event, | |
1510 | struct evlist **pevlist) | |
1511 | { | |
1512 | int ret; | |
1513 | ||
1514 | ret = perf_event__process_event_update(tool, event, pevlist); | |
1515 | if (ret < 0) | |
1516 | return ret; | |
1517 | ||
1518 | /* this can return -EEXIST since we call it for each evsel */ | |
1519 | perf_session__set_tracepoints_handlers(session, lock_tracepoints); | |
1520 | perf_session__set_tracepoints_handlers(session, contention_tracepoints); | |
1521 | return 0; | |
1522 | } | |
1523 | ||
32dcd021 | 1524 | typedef int (*tracepoint_handler)(struct evsel *evsel, |
746f16ec ACM |
1525 | struct perf_sample *sample); |
1526 | ||
1d037ca1 | 1527 | static int process_sample_event(struct perf_tool *tool __maybe_unused, |
d20deb64 | 1528 | union perf_event *event, |
9e69c210 | 1529 | struct perf_sample *sample, |
32dcd021 | 1530 | struct evsel *evsel, |
743eb868 | 1531 | struct machine *machine) |
c61e52ee | 1532 | { |
b91fc39f | 1533 | int err = 0; |
314add6b AH |
1534 | struct thread *thread = machine__findnew_thread(machine, sample->pid, |
1535 | sample->tid); | |
c61e52ee | 1536 | |
c61e52ee FW |
1537 | if (thread == NULL) { |
1538 | pr_debug("problem processing %d event, skipping it.\n", | |
8115d60c | 1539 | event->header.type); |
c61e52ee FW |
1540 | return -1; |
1541 | } | |
1542 | ||
744a9719 ACM |
1543 | if (evsel->handler != NULL) { |
1544 | tracepoint_handler f = evsel->handler; | |
b91fc39f | 1545 | err = f(evsel, sample); |
746f16ec ACM |
1546 | } |
1547 | ||
b91fc39f ACM |
1548 | thread__put(thread); |
1549 | ||
1550 | return err; | |
c61e52ee FW |
1551 | } |
1552 | ||
0d435bf8 NK |
1553 | static void combine_result(void) |
1554 | { | |
1555 | unsigned int i; | |
1556 | struct lock_stat *st; | |
1557 | ||
1558 | if (!combine_locks) | |
1559 | return; | |
1560 | ||
1561 | for (i = 0; i < LOCKHASH_SIZE; i++) { | |
1562 | hlist_for_each_entry(st, &lockhash_table[i], hash_entry) { | |
1563 | combine_lock_stats(st); | |
1564 | } | |
1565 | } | |
1566 | } | |
1567 | ||
375eb2be DB |
1568 | static void sort_result(void) |
1569 | { | |
1570 | unsigned int i; | |
1571 | struct lock_stat *st; | |
1572 | ||
1573 | for (i = 0; i < LOCKHASH_SIZE; i++) { | |
7672d00a | 1574 | hlist_for_each_entry(st, &lockhash_table[i], hash_entry) { |
375eb2be DB |
1575 | insert_to_result(st, compare); |
1576 | } | |
1577 | } | |
1578 | } | |
1579 | ||
59119c09 NK |
1580 | static const struct { |
1581 | unsigned int flags; | |
4f701063 | 1582 | const char *str; |
59119c09 NK |
1583 | const char *name; |
1584 | } lock_type_table[] = { | |
4f701063 NK |
1585 | { 0, "semaphore", "semaphore" }, |
1586 | { LCB_F_SPIN, "spinlock", "spinlock" }, | |
1587 | { LCB_F_SPIN | LCB_F_READ, "rwlock:R", "rwlock" }, | |
1588 | { LCB_F_SPIN | LCB_F_WRITE, "rwlock:W", "rwlock" }, | |
1589 | { LCB_F_READ, "rwsem:R", "rwsem" }, | |
1590 | { LCB_F_WRITE, "rwsem:W", "rwsem" }, | |
d783ea8f | 1591 | { LCB_F_RT, "rt-mutex", "rt-mutex" }, |
4f701063 NK |
1592 | { LCB_F_RT | LCB_F_READ, "rwlock-rt:R", "rwlock-rt" }, |
1593 | { LCB_F_RT | LCB_F_WRITE, "rwlock-rt:W", "rwlock-rt" }, | |
1594 | { LCB_F_PERCPU | LCB_F_READ, "pcpu-sem:R", "percpu-rwsem" }, | |
1595 | { LCB_F_PERCPU | LCB_F_WRITE, "pcpu-sem:W", "percpu-rwsem" }, | |
1596 | { LCB_F_MUTEX, "mutex", "mutex" }, | |
1597 | { LCB_F_MUTEX | LCB_F_SPIN, "mutex", "mutex" }, | |
b4a7eff9 | 1598 | /* alias for get_type_flag() */ |
4f701063 | 1599 | { LCB_F_MUTEX | LCB_F_SPIN, "mutex-spin", "mutex" }, |
59119c09 | 1600 | }; |
528b9cab | 1601 | |
59119c09 NK |
1602 | static const char *get_type_str(unsigned int flags) |
1603 | { | |
4f701063 NK |
1604 | flags &= LCB_F_MAX_FLAGS - 1; |
1605 | ||
1606 | for (unsigned int i = 0; i < ARRAY_SIZE(lock_type_table); i++) { | |
1607 | if (lock_type_table[i].flags == flags) | |
1608 | return lock_type_table[i].str; | |
1609 | } | |
1610 | return "unknown"; | |
1611 | } | |
1612 | ||
1613 | static const char *get_type_name(unsigned int flags) | |
1614 | { | |
1615 | flags &= LCB_F_MAX_FLAGS - 1; | |
1616 | ||
59119c09 NK |
1617 | for (unsigned int i = 0; i < ARRAY_SIZE(lock_type_table); i++) { |
1618 | if (lock_type_table[i].flags == flags) | |
1619 | return lock_type_table[i].name; | |
528b9cab NK |
1620 | } |
1621 | return "unknown"; | |
1622 | } | |
1623 | ||
b4a7eff9 NK |
1624 | static unsigned int get_type_flag(const char *str) |
1625 | { | |
1626 | for (unsigned int i = 0; i < ARRAY_SIZE(lock_type_table); i++) { | |
1627 | if (!strcmp(lock_type_table[i].name, str)) | |
1628 | return lock_type_table[i].flags; | |
1629 | } | |
d783ea8f NK |
1630 | for (unsigned int i = 0; i < ARRAY_SIZE(lock_type_table); i++) { |
1631 | if (!strcmp(lock_type_table[i].str, str)) | |
1632 | return lock_type_table[i].flags; | |
1633 | } | |
b4a7eff9 NK |
1634 | return UINT_MAX; |
1635 | } | |
1636 | ||
1637 | static void lock_filter_finish(void) | |
1638 | { | |
1639 | zfree(&filters.types); | |
1640 | filters.nr_types = 0; | |
511e19b9 NK |
1641 | |
1642 | zfree(&filters.addrs); | |
1643 | filters.nr_addrs = 0; | |
1644 | ||
1645 | for (int i = 0; i < filters.nr_syms; i++) | |
1646 | free(filters.syms[i]); | |
1647 | ||
1648 | zfree(&filters.syms); | |
1649 | filters.nr_syms = 0; | |
4fd06bd2 NK |
1650 | |
1651 | zfree(&filters.cgrps); | |
1652 | filters.nr_cgrps = 0; | |
b4a7eff9 NK |
1653 | } |
1654 | ||
528b9cab NK |
1655 | static void sort_contention_result(void) |
1656 | { | |
1657 | sort_result(); | |
1658 | } | |
1659 | ||
69c5c993 NK |
1660 | static void print_header_stdio(void) |
1661 | { | |
1662 | struct lock_key *key; | |
1663 | ||
1664 | list_for_each_entry(key, &lock_keys, list) | |
f6027053 | 1665 | fprintf(lock_output, "%*s ", key->len, key->header); |
69c5c993 NK |
1666 | |
1667 | switch (aggr_mode) { | |
1668 | case LOCK_AGGR_TASK: | |
f6027053 | 1669 | fprintf(lock_output, " %10s %s\n\n", "pid", |
69c5c993 NK |
1670 | show_lock_owner ? "owner" : "comm"); |
1671 | break; | |
1672 | case LOCK_AGGR_CALLER: | |
f6027053 | 1673 | fprintf(lock_output, " %10s %s\n\n", "type", "caller"); |
69c5c993 NK |
1674 | break; |
1675 | case LOCK_AGGR_ADDR: | |
f6027053 | 1676 | fprintf(lock_output, " %16s %s\n\n", "address", "symbol"); |
69c5c993 | 1677 | break; |
4d1792d0 NK |
1678 | case LOCK_AGGR_CGROUP: |
1679 | fprintf(lock_output, " %s\n\n", "cgroup"); | |
1680 | break; | |
69c5c993 NK |
1681 | default: |
1682 | break; | |
1683 | } | |
1684 | } | |
1685 | ||
1686 | static void print_header_csv(const char *sep) | |
1687 | { | |
1688 | struct lock_key *key; | |
1689 | ||
f6027053 | 1690 | fprintf(lock_output, "# output: "); |
69c5c993 | 1691 | list_for_each_entry(key, &lock_keys, list) |
f6027053 | 1692 | fprintf(lock_output, "%s%s ", key->header, sep); |
69c5c993 NK |
1693 | |
1694 | switch (aggr_mode) { | |
1695 | case LOCK_AGGR_TASK: | |
f6027053 | 1696 | fprintf(lock_output, "%s%s %s\n", "pid", sep, |
69c5c993 NK |
1697 | show_lock_owner ? "owner" : "comm"); |
1698 | break; | |
1699 | case LOCK_AGGR_CALLER: | |
f6027053 | 1700 | fprintf(lock_output, "%s%s %s", "type", sep, "caller"); |
69c5c993 | 1701 | if (verbose > 0) |
f6027053 NK |
1702 | fprintf(lock_output, "%s %s", sep, "stacktrace"); |
1703 | fprintf(lock_output, "\n"); | |
69c5c993 NK |
1704 | break; |
1705 | case LOCK_AGGR_ADDR: | |
f6027053 | 1706 | fprintf(lock_output, "%s%s %s%s %s\n", "address", sep, "symbol", sep, "type"); |
69c5c993 | 1707 | break; |
4d1792d0 NK |
1708 | case LOCK_AGGR_CGROUP: |
1709 | fprintf(lock_output, "%s\n", "cgroup"); | |
1710 | break; | |
69c5c993 NK |
1711 | default: |
1712 | break; | |
1713 | } | |
1714 | } | |
1715 | ||
1716 | static void print_header(void) | |
1717 | { | |
1718 | if (!quiet) { | |
1719 | if (symbol_conf.field_sep) | |
1720 | print_header_csv(symbol_conf.field_sep); | |
1721 | else | |
1722 | print_header_stdio(); | |
1723 | } | |
1724 | } | |
1725 | ||
1726 | static void print_lock_stat_stdio(struct lock_contention *con, struct lock_stat *st) | |
1727 | { | |
1728 | struct lock_key *key; | |
1729 | struct thread *t; | |
1730 | int pid; | |
1731 | ||
1732 | list_for_each_entry(key, &lock_keys, list) { | |
1733 | key->print(key, st); | |
f6027053 | 1734 | fprintf(lock_output, " "); |
69c5c993 NK |
1735 | } |
1736 | ||
1737 | switch (aggr_mode) { | |
1738 | case LOCK_AGGR_CALLER: | |
f6027053 | 1739 | fprintf(lock_output, " %10s %s\n", get_type_str(st->flags), st->name); |
69c5c993 NK |
1740 | break; |
1741 | case LOCK_AGGR_TASK: | |
1742 | pid = st->addr; | |
1743 | t = perf_session__findnew(session, pid); | |
f6027053 | 1744 | fprintf(lock_output, " %10d %s\n", |
69c5c993 NK |
1745 | pid, pid == -1 ? "Unknown" : thread__comm_str(t)); |
1746 | break; | |
1747 | case LOCK_AGGR_ADDR: | |
f6027053 | 1748 | fprintf(lock_output, " %016llx %s (%s)\n", (unsigned long long)st->addr, |
69c5c993 NK |
1749 | st->name, get_type_name(st->flags)); |
1750 | break; | |
4d1792d0 NK |
1751 | case LOCK_AGGR_CGROUP: |
1752 | fprintf(lock_output, " %s\n", st->name); | |
1753 | break; | |
69c5c993 NK |
1754 | default: |
1755 | break; | |
1756 | } | |
1757 | ||
1758 | if (aggr_mode == LOCK_AGGR_CALLER && verbose > 0) { | |
1759 | struct map *kmap; | |
1760 | struct symbol *sym; | |
1761 | char buf[128]; | |
1762 | u64 ip; | |
1763 | ||
1764 | for (int i = 0; i < max_stack_depth; i++) { | |
1765 | if (!st->callstack || !st->callstack[i]) | |
1766 | break; | |
1767 | ||
1768 | ip = st->callstack[i]; | |
1769 | sym = machine__find_kernel_symbol(con->machine, ip, &kmap); | |
1770 | get_symbol_name_offset(kmap, sym, ip, buf, sizeof(buf)); | |
f6027053 | 1771 | fprintf(lock_output, "\t\t\t%#lx %s\n", (unsigned long)ip, buf); |
69c5c993 NK |
1772 | } |
1773 | } | |
1774 | } | |
1775 | ||
1776 | static void print_lock_stat_csv(struct lock_contention *con, struct lock_stat *st, | |
1777 | const char *sep) | |
1778 | { | |
1779 | struct lock_key *key; | |
1780 | struct thread *t; | |
1781 | int pid; | |
1782 | ||
1783 | list_for_each_entry(key, &lock_keys, list) { | |
1784 | key->print(key, st); | |
f6027053 | 1785 | fprintf(lock_output, "%s ", sep); |
69c5c993 NK |
1786 | } |
1787 | ||
1788 | switch (aggr_mode) { | |
1789 | case LOCK_AGGR_CALLER: | |
f6027053 | 1790 | fprintf(lock_output, "%s%s %s", get_type_str(st->flags), sep, st->name); |
69c5c993 | 1791 | if (verbose <= 0) |
f6027053 | 1792 | fprintf(lock_output, "\n"); |
69c5c993 NK |
1793 | break; |
1794 | case LOCK_AGGR_TASK: | |
1795 | pid = st->addr; | |
1796 | t = perf_session__findnew(session, pid); | |
f6027053 NK |
1797 | fprintf(lock_output, "%d%s %s\n", pid, sep, |
1798 | pid == -1 ? "Unknown" : thread__comm_str(t)); | |
69c5c993 NK |
1799 | break; |
1800 | case LOCK_AGGR_ADDR: | |
f6027053 | 1801 | fprintf(lock_output, "%llx%s %s%s %s\n", (unsigned long long)st->addr, sep, |
69c5c993 NK |
1802 | st->name, sep, get_type_name(st->flags)); |
1803 | break; | |
4d1792d0 NK |
1804 | case LOCK_AGGR_CGROUP: |
1805 | fprintf(lock_output, "%s\n",st->name); | |
1806 | break; | |
69c5c993 NK |
1807 | default: |
1808 | break; | |
1809 | } | |
1810 | ||
1811 | if (aggr_mode == LOCK_AGGR_CALLER && verbose > 0) { | |
1812 | struct map *kmap; | |
1813 | struct symbol *sym; | |
1814 | char buf[128]; | |
1815 | u64 ip; | |
1816 | ||
1817 | for (int i = 0; i < max_stack_depth; i++) { | |
1818 | if (!st->callstack || !st->callstack[i]) | |
1819 | break; | |
1820 | ||
1821 | ip = st->callstack[i]; | |
1822 | sym = machine__find_kernel_symbol(con->machine, ip, &kmap); | |
1823 | get_symbol_name_offset(kmap, sym, ip, buf, sizeof(buf)); | |
f6027053 | 1824 | fprintf(lock_output, "%s %#lx %s", i ? ":" : sep, (unsigned long) ip, buf); |
69c5c993 | 1825 | } |
f6027053 | 1826 | fprintf(lock_output, "\n"); |
69c5c993 NK |
1827 | } |
1828 | } | |
1829 | ||
1830 | static void print_lock_stat(struct lock_contention *con, struct lock_stat *st) | |
1831 | { | |
1832 | if (symbol_conf.field_sep) | |
1833 | print_lock_stat_csv(con, st, symbol_conf.field_sep); | |
1834 | else | |
1835 | print_lock_stat_stdio(con, st); | |
1836 | } | |
1837 | ||
1838 | static void print_footer_stdio(int total, int bad, struct lock_contention_fails *fails) | |
84c3a2bb NK |
1839 | { |
1840 | /* Output for debug, this have to be removed */ | |
954cdac7 | 1841 | int broken = fails->task + fails->stack + fails->time + fails->data; |
84c3a2bb | 1842 | |
69c5c993 NK |
1843 | if (!use_bpf) |
1844 | print_bad_events(bad, total); | |
1845 | ||
84c3a2bb NK |
1846 | if (quiet || total == 0 || (broken == 0 && verbose <= 0)) |
1847 | return; | |
1848 | ||
1849 | total += broken; | |
f6027053 NK |
1850 | fprintf(lock_output, "\n=== output for debug ===\n\n"); |
1851 | fprintf(lock_output, "bad: %d, total: %d\n", broken, total); | |
1852 | fprintf(lock_output, "bad rate: %.2f %%\n", 100.0 * broken / total); | |
84c3a2bb | 1853 | |
f6027053 NK |
1854 | fprintf(lock_output, "histogram of failure reasons\n"); |
1855 | fprintf(lock_output, " %10s: %d\n", "task", fails->task); | |
1856 | fprintf(lock_output, " %10s: %d\n", "stack", fails->stack); | |
1857 | fprintf(lock_output, " %10s: %d\n", "time", fails->time); | |
1858 | fprintf(lock_output, " %10s: %d\n", "data", fails->data); | |
84c3a2bb | 1859 | } |
954cdac7 | 1860 | |
69c5c993 NK |
1861 | static void print_footer_csv(int total, int bad, struct lock_contention_fails *fails, |
1862 | const char *sep) | |
1863 | { | |
1864 | /* Output for debug, this have to be removed */ | |
1865 | if (use_bpf) | |
1866 | bad = fails->task + fails->stack + fails->time + fails->data; | |
1867 | ||
1868 | if (quiet || total == 0 || (bad == 0 && verbose <= 0)) | |
1869 | return; | |
1870 | ||
1871 | total += bad; | |
f6027053 | 1872 | fprintf(lock_output, "# debug: total=%d%s bad=%d", total, sep, bad); |
69c5c993 NK |
1873 | |
1874 | if (use_bpf) { | |
f6027053 NK |
1875 | fprintf(lock_output, "%s bad_%s=%d", sep, "task", fails->task); |
1876 | fprintf(lock_output, "%s bad_%s=%d", sep, "stack", fails->stack); | |
1877 | fprintf(lock_output, "%s bad_%s=%d", sep, "time", fails->time); | |
1878 | fprintf(lock_output, "%s bad_%s=%d", sep, "data", fails->data); | |
69c5c993 NK |
1879 | } else { |
1880 | int i; | |
1881 | const char *name[4] = { "acquire", "acquired", "contended", "release" }; | |
1882 | ||
1883 | for (i = 0; i < BROKEN_MAX; i++) | |
f6027053 | 1884 | fprintf(lock_output, "%s bad_%s=%d", sep, name[i], bad_hist[i]); |
69c5c993 | 1885 | } |
f6027053 | 1886 | fprintf(lock_output, "\n"); |
69c5c993 NK |
1887 | } |
1888 | ||
1889 | static void print_footer(int total, int bad, struct lock_contention_fails *fails) | |
1890 | { | |
1891 | if (symbol_conf.field_sep) | |
1892 | print_footer_csv(total, bad, fails, symbol_conf.field_sep); | |
1893 | else | |
1894 | print_footer_stdio(total, bad, fails); | |
1895 | } | |
1896 | ||
a6eaf966 | 1897 | static void print_contention_result(struct lock_contention *con) |
528b9cab NK |
1898 | { |
1899 | struct lock_stat *st; | |
6282a1f4 | 1900 | int bad, total, printed; |
528b9cab | 1901 | |
69c5c993 NK |
1902 | if (!quiet) |
1903 | print_header(); | |
528b9cab | 1904 | |
6282a1f4 | 1905 | bad = total = printed = 0; |
6d499a6b | 1906 | |
528b9cab | 1907 | while ((st = pop_from_result())) { |
6d499a6b | 1908 | total += use_bpf ? st->nr_contended : 1; |
528b9cab NK |
1909 | if (st->broken) |
1910 | bad++; | |
1911 | ||
b4a7eff9 NK |
1912 | if (!st->wait_time_total) |
1913 | continue; | |
1914 | ||
69c5c993 | 1915 | print_lock_stat(con, st); |
6282a1f4 | 1916 | |
6282a1f4 NK |
1917 | if (++printed >= print_nr_entries) |
1918 | break; | |
528b9cab NK |
1919 | } |
1920 | ||
aae7e453 NK |
1921 | if (print_nr_entries) { |
1922 | /* update the total/bad stats */ | |
1923 | while ((st = pop_from_result())) { | |
1924 | total += use_bpf ? st->nr_contended : 1; | |
1925 | if (st->broken) | |
1926 | bad++; | |
1927 | } | |
1928 | } | |
1929 | /* some entries are collected but hidden by the callstack filter */ | |
1930 | total += con->nr_filtered; | |
1931 | ||
69c5c993 | 1932 | print_footer(total, bad, &con->fails); |
528b9cab NK |
1933 | } |
1934 | ||
c4ac732a YS |
1935 | static bool force; |
1936 | ||
375eb2be | 1937 | static int __cmd_report(bool display_info) |
9b5e350c | 1938 | { |
375eb2be | 1939 | int err = -EINVAL; |
c75d98af | 1940 | struct perf_tool eops = { |
30b331d2 NK |
1941 | .attr = perf_event__process_attr, |
1942 | .event_update = process_event_update, | |
c75d98af ACM |
1943 | .sample = process_sample_event, |
1944 | .comm = perf_event__process_comm, | |
0d2997f7 | 1945 | .mmap = perf_event__process_mmap, |
f3b3614a | 1946 | .namespaces = perf_event__process_namespaces, |
30b331d2 | 1947 | .tracing_data = perf_event__process_tracing_data, |
0a8cb85c | 1948 | .ordered_events = true, |
c75d98af | 1949 | }; |
8ceb41d7 | 1950 | struct perf_data data = { |
2d4f2799 JO |
1951 | .path = input_name, |
1952 | .mode = PERF_DATA_MODE_READ, | |
1953 | .force = force, | |
f5fc1412 | 1954 | }; |
375eb2be | 1955 | |
2681bd85 | 1956 | session = perf_session__new(&data, &eops); |
6ef81c55 | 1957 | if (IS_ERR(session)) { |
33d6aef5 | 1958 | pr_err("Initializing perf session failed\n"); |
6ef81c55 | 1959 | return PTR_ERR(session); |
33d6aef5 | 1960 | } |
9b5e350c | 1961 | |
d8d85ce8 | 1962 | symbol_conf.allow_aliases = true; |
0a7e6d1b | 1963 | symbol__init(&session->header.env); |
6fd6c6b4 | 1964 | |
30b331d2 NK |
1965 | if (!data.is_pipe) { |
1966 | if (!perf_session__has_traces(session, "lock record")) | |
1967 | goto out_delete; | |
375eb2be | 1968 | |
30b331d2 NK |
1969 | if (perf_session__set_tracepoints_handlers(session, lock_tracepoints)) { |
1970 | pr_err("Initializing perf session tracepoint handlers failed\n"); | |
1971 | goto out_delete; | |
1972 | } | |
746f16ec | 1973 | |
30b331d2 NK |
1974 | if (perf_session__set_tracepoints_handlers(session, contention_tracepoints)) { |
1975 | pr_err("Initializing perf session tracepoint handlers failed\n"); | |
1976 | goto out_delete; | |
1977 | } | |
3ae03f26 NK |
1978 | } |
1979 | ||
79079f21 | 1980 | if (setup_output_field(false, output_fields)) |
64999e44 NK |
1981 | goto out_delete; |
1982 | ||
79079f21 | 1983 | if (select_key(false)) |
375eb2be | 1984 | goto out_delete; |
9b5e350c | 1985 | |
f9c695a2 NK |
1986 | if (show_thread_stats) |
1987 | aggr_mode = LOCK_AGGR_TASK; | |
1988 | ||
b7b61cbe | 1989 | err = perf_session__process_events(session); |
375eb2be DB |
1990 | if (err) |
1991 | goto out_delete; | |
9b5e350c | 1992 | |
9b5e350c | 1993 | setup_pager(); |
375eb2be DB |
1994 | if (display_info) /* used for info subcommand */ |
1995 | err = dump_info(); | |
1996 | else { | |
0d435bf8 | 1997 | combine_result(); |
375eb2be DB |
1998 | sort_result(); |
1999 | print_result(); | |
2000 | } | |
33d6aef5 | 2001 | |
375eb2be DB |
2002 | out_delete: |
2003 | perf_session__delete(session); | |
2004 | return err; | |
9b5e350c HM |
2005 | } |
2006 | ||
407b36f6 NK |
2007 | static void sighandler(int sig __maybe_unused) |
2008 | { | |
2009 | } | |
2010 | ||
3477f079 NK |
2011 | static int check_lock_contention_options(const struct option *options, |
2012 | const char * const *usage) | |
2013 | ||
2014 | { | |
2015 | if (show_thread_stats && show_lock_addrs) { | |
2016 | pr_err("Cannot use thread and addr mode together\n"); | |
2017 | parse_options_usage(usage, options, "threads", 0); | |
2018 | parse_options_usage(NULL, options, "lock-addr", 0); | |
2019 | return -1; | |
2020 | } | |
2021 | ||
2022 | if (show_lock_owner && !use_bpf) { | |
2023 | pr_err("Lock owners are available only with BPF\n"); | |
2024 | parse_options_usage(usage, options, "lock-owner", 0); | |
2025 | parse_options_usage(NULL, options, "use-bpf", 0); | |
2026 | return -1; | |
2027 | } | |
2028 | ||
2029 | if (show_lock_owner && show_lock_addrs) { | |
2030 | pr_err("Cannot use owner and addr mode together\n"); | |
2031 | parse_options_usage(usage, options, "lock-owner", 0); | |
2032 | parse_options_usage(NULL, options, "lock-addr", 0); | |
2033 | return -1; | |
2034 | } | |
2035 | ||
4d1792d0 NK |
2036 | if (show_lock_cgroups && !use_bpf) { |
2037 | pr_err("Cgroups are available only with BPF\n"); | |
2038 | parse_options_usage(usage, options, "lock-cgroup", 0); | |
2039 | parse_options_usage(NULL, options, "use-bpf", 0); | |
2040 | return -1; | |
2041 | } | |
2042 | ||
2043 | if (show_lock_cgroups && show_lock_addrs) { | |
2044 | pr_err("Cannot use cgroup and addr mode together\n"); | |
2045 | parse_options_usage(usage, options, "lock-cgroup", 0); | |
2046 | parse_options_usage(NULL, options, "lock-addr", 0); | |
2047 | return -1; | |
2048 | } | |
2049 | ||
2050 | if (show_lock_cgroups && show_thread_stats) { | |
2051 | pr_err("Cannot use cgroup and thread mode together\n"); | |
2052 | parse_options_usage(usage, options, "lock-cgroup", 0); | |
2053 | parse_options_usage(NULL, options, "threads", 0); | |
2054 | return -1; | |
2055 | } | |
2056 | ||
69c5c993 NK |
2057 | if (symbol_conf.field_sep) { |
2058 | if (strstr(symbol_conf.field_sep, ":") || /* part of type flags */ | |
2059 | strstr(symbol_conf.field_sep, "+") || /* part of caller offset */ | |
2060 | strstr(symbol_conf.field_sep, ".")) { /* can be in a symbol name */ | |
2061 | pr_err("Cannot use the separator that is already used\n"); | |
2062 | parse_options_usage(usage, options, "x", 1); | |
2063 | return -1; | |
2064 | } | |
2065 | } | |
2066 | ||
3477f079 NK |
2067 | if (show_lock_owner) |
2068 | show_thread_stats = true; | |
2069 | ||
2070 | return 0; | |
2071 | } | |
2072 | ||
6fda2405 | 2073 | static int __cmd_contention(int argc, const char **argv) |
528b9cab NK |
2074 | { |
2075 | int err = -EINVAL; | |
2076 | struct perf_tool eops = { | |
30b331d2 NK |
2077 | .attr = perf_event__process_attr, |
2078 | .event_update = process_event_update, | |
528b9cab NK |
2079 | .sample = process_sample_event, |
2080 | .comm = perf_event__process_comm, | |
2081 | .mmap = perf_event__process_mmap, | |
30b331d2 | 2082 | .tracing_data = perf_event__process_tracing_data, |
528b9cab NK |
2083 | .ordered_events = true, |
2084 | }; | |
2085 | struct perf_data data = { | |
2086 | .path = input_name, | |
2087 | .mode = PERF_DATA_MODE_READ, | |
2088 | .force = force, | |
2089 | }; | |
447ec4e5 NK |
2090 | struct lock_contention con = { |
2091 | .target = &target, | |
ceb13bfc | 2092 | .map_nr_entries = bpf_map_entries, |
96532a83 NK |
2093 | .max_stack = max_stack_depth, |
2094 | .stack_skip = stack_skip, | |
529772c4 | 2095 | .filters = &filters, |
7b204399 | 2096 | .save_callstack = needs_callstack(), |
3477f079 | 2097 | .owner = show_lock_owner, |
d0c502e4 | 2098 | .cgroups = RB_ROOT, |
447ec4e5 | 2099 | }; |
528b9cab | 2100 | |
eef4fee5 IR |
2101 | lockhash_table = calloc(LOCKHASH_SIZE, sizeof(*lockhash_table)); |
2102 | if (!lockhash_table) | |
2103 | return -ENOMEM; | |
2104 | ||
2105 | con.result = &lockhash_table[0]; | |
2106 | ||
407b36f6 | 2107 | session = perf_session__new(use_bpf ? NULL : &data, &eops); |
528b9cab NK |
2108 | if (IS_ERR(session)) { |
2109 | pr_err("Initializing perf session failed\n"); | |
eef4fee5 | 2110 | err = PTR_ERR(session); |
abaf1e03 | 2111 | session = NULL; |
eef4fee5 | 2112 | goto out_delete; |
528b9cab NK |
2113 | } |
2114 | ||
a6eaf966 NK |
2115 | con.machine = &session->machines.host; |
2116 | ||
688d2e8d | 2117 | con.aggr_mode = aggr_mode = show_thread_stats ? LOCK_AGGR_TASK : |
4d1792d0 NK |
2118 | show_lock_addrs ? LOCK_AGGR_ADDR : |
2119 | show_lock_cgroups ? LOCK_AGGR_CGROUP : LOCK_AGGR_CALLER; | |
688d2e8d | 2120 | |
55e39185 NK |
2121 | if (con.aggr_mode == LOCK_AGGR_CALLER) |
2122 | con.save_callstack = true; | |
2123 | ||
d8d85ce8 | 2124 | symbol_conf.allow_aliases = true; |
528b9cab NK |
2125 | symbol__init(&session->header.env); |
2126 | ||
407b36f6 | 2127 | if (use_bpf) { |
6fda2405 NK |
2128 | err = target__validate(&target); |
2129 | if (err) { | |
2130 | char errbuf[512]; | |
2131 | ||
2132 | target__strerror(&target, err, errbuf, 512); | |
2133 | pr_err("%s\n", errbuf); | |
2134 | goto out_delete; | |
407b36f6 | 2135 | } |
528b9cab | 2136 | |
407b36f6 NK |
2137 | signal(SIGINT, sighandler); |
2138 | signal(SIGCHLD, sighandler); | |
2139 | signal(SIGTERM, sighandler); | |
6fda2405 | 2140 | |
447ec4e5 NK |
2141 | con.evlist = evlist__new(); |
2142 | if (con.evlist == NULL) { | |
6fda2405 NK |
2143 | err = -ENOMEM; |
2144 | goto out_delete; | |
2145 | } | |
2146 | ||
447ec4e5 | 2147 | err = evlist__create_maps(con.evlist, &target); |
6fda2405 NK |
2148 | if (err < 0) |
2149 | goto out_delete; | |
2150 | ||
2151 | if (argc) { | |
447ec4e5 | 2152 | err = evlist__prepare_workload(con.evlist, &target, |
6fda2405 NK |
2153 | argv, false, NULL); |
2154 | if (err < 0) | |
2155 | goto out_delete; | |
2156 | } | |
2157 | ||
447ec4e5 | 2158 | if (lock_contention_prepare(&con) < 0) { |
6fda2405 NK |
2159 | pr_err("lock contention BPF setup failed\n"); |
2160 | goto out_delete; | |
2161 | } | |
30b331d2 | 2162 | } else if (!data.is_pipe) { |
407b36f6 NK |
2163 | if (!perf_session__has_traces(session, "lock record")) |
2164 | goto out_delete; | |
528b9cab | 2165 | |
407b36f6 NK |
2166 | if (!evlist__find_evsel_by_str(session->evlist, |
2167 | "lock:contention_begin")) { | |
2168 | pr_err("lock contention evsel not found\n"); | |
2169 | goto out_delete; | |
2170 | } | |
2171 | ||
2172 | if (perf_session__set_tracepoints_handlers(session, | |
2173 | contention_tracepoints)) { | |
2174 | pr_err("Initializing perf session tracepoint handlers failed\n"); | |
2175 | goto out_delete; | |
2176 | } | |
528b9cab NK |
2177 | } |
2178 | ||
79079f21 | 2179 | if (setup_output_field(true, output_fields)) |
528b9cab NK |
2180 | goto out_delete; |
2181 | ||
79079f21 | 2182 | if (select_key(true)) |
528b9cab NK |
2183 | goto out_delete; |
2184 | ||
69c5c993 NK |
2185 | if (symbol_conf.field_sep) { |
2186 | int i; | |
2187 | struct lock_key *keys = contention_keys; | |
2188 | ||
2189 | /* do not align output in CSV format */ | |
2190 | for (i = 0; keys[i].name; i++) | |
2191 | keys[i].len = 0; | |
2192 | } | |
2193 | ||
407b36f6 NK |
2194 | if (use_bpf) { |
2195 | lock_contention_start(); | |
6fda2405 | 2196 | if (argc) |
447ec4e5 | 2197 | evlist__start_workload(con.evlist); |
407b36f6 NK |
2198 | |
2199 | /* wait for signal */ | |
2200 | pause(); | |
2201 | ||
2202 | lock_contention_stop(); | |
447ec4e5 | 2203 | lock_contention_read(&con); |
407b36f6 NK |
2204 | } else { |
2205 | err = perf_session__process_events(session); | |
2206 | if (err) | |
2207 | goto out_delete; | |
2208 | } | |
528b9cab NK |
2209 | |
2210 | setup_pager(); | |
2211 | ||
2212 | sort_contention_result(); | |
a6eaf966 | 2213 | print_contention_result(&con); |
528b9cab NK |
2214 | |
2215 | out_delete: | |
b4a7eff9 | 2216 | lock_filter_finish(); |
447ec4e5 | 2217 | evlist__delete(con.evlist); |
d0c502e4 | 2218 | lock_contention_finish(&con); |
528b9cab | 2219 | perf_session__delete(session); |
eef4fee5 | 2220 | zfree(&lockhash_table); |
528b9cab NK |
2221 | return err; |
2222 | } | |
2223 | ||
2224 | ||
9b5e350c HM |
2225 | static int __cmd_record(int argc, const char **argv) |
2226 | { | |
c75d98af | 2227 | const char *record_args[] = { |
2762c488 | 2228 | "record", "-R", "-m", "1024", "-c", "1", "--synth", "task", |
c75d98af | 2229 | }; |
0d2997f7 NK |
2230 | const char *callgraph_args[] = { |
2231 | "--call-graph", "fp," __stringify(CONTENTION_STACK_DEPTH), | |
2232 | }; | |
0a98c7fe | 2233 | unsigned int rec_argc, i, j, ret; |
166a9764 | 2234 | unsigned int nr_tracepoints; |
0d2997f7 | 2235 | unsigned int nr_callgraph_args = 0; |
9b5e350c | 2236 | const char **rec_argv; |
166a9764 | 2237 | bool has_lock_stat = true; |
9b5e350c | 2238 | |
d25dcba8 | 2239 | for (i = 0; i < ARRAY_SIZE(lock_tracepoints); i++) { |
746f16ec | 2240 | if (!is_valid_tracepoint(lock_tracepoints[i].name)) { |
166a9764 NK |
2241 | pr_debug("tracepoint %s is not enabled. " |
2242 | "Are CONFIG_LOCKDEP and CONFIG_LOCK_STAT enabled?\n", | |
2243 | lock_tracepoints[i].name); | |
2244 | has_lock_stat = false; | |
2245 | break; | |
2246 | } | |
2247 | } | |
2248 | ||
2249 | if (has_lock_stat) | |
2250 | goto setup_args; | |
2251 | ||
2252 | for (i = 0; i < ARRAY_SIZE(contention_tracepoints); i++) { | |
2253 | if (!is_valid_tracepoint(contention_tracepoints[i].name)) { | |
2254 | pr_err("tracepoint %s is not enabled.\n", | |
2255 | contention_tracepoints[i].name); | |
2256 | return 1; | |
d25dcba8 DA |
2257 | } |
2258 | } | |
2259 | ||
0d2997f7 NK |
2260 | nr_callgraph_args = ARRAY_SIZE(callgraph_args); |
2261 | ||
166a9764 | 2262 | setup_args: |
0d2997f7 | 2263 | rec_argc = ARRAY_SIZE(record_args) + nr_callgraph_args + argc - 1; |
166a9764 NK |
2264 | |
2265 | if (has_lock_stat) | |
2266 | nr_tracepoints = ARRAY_SIZE(lock_tracepoints); | |
2267 | else | |
2268 | nr_tracepoints = ARRAY_SIZE(contention_tracepoints); | |
2269 | ||
d25dcba8 | 2270 | /* factor of 2 is for -e in front of each tracepoint */ |
166a9764 | 2271 | rec_argc += 2 * nr_tracepoints; |
9b5e350c | 2272 | |
d25dcba8 | 2273 | rec_argv = calloc(rec_argc + 1, sizeof(char *)); |
0a98c7fe | 2274 | if (!rec_argv) |
ce47dc56 CS |
2275 | return -ENOMEM; |
2276 | ||
9b5e350c HM |
2277 | for (i = 0; i < ARRAY_SIZE(record_args); i++) |
2278 | rec_argv[i] = strdup(record_args[i]); | |
2279 | ||
166a9764 NK |
2280 | for (j = 0; j < nr_tracepoints; j++) { |
2281 | const char *ev_name; | |
2282 | ||
2283 | if (has_lock_stat) | |
2284 | ev_name = strdup(lock_tracepoints[j].name); | |
2285 | else | |
2286 | ev_name = strdup(contention_tracepoints[j].name); | |
2287 | ||
4a18ab46 | 2288 | if (!ev_name) { |
2289 | free(rec_argv); | |
166a9764 | 2290 | return -ENOMEM; |
4a18ab46 | 2291 | } |
166a9764 | 2292 | |
d25dcba8 | 2293 | rec_argv[i++] = "-e"; |
166a9764 | 2294 | rec_argv[i++] = ev_name; |
d25dcba8 DA |
2295 | } |
2296 | ||
0d2997f7 NK |
2297 | for (j = 0; j < nr_callgraph_args; j++, i++) |
2298 | rec_argv[i] = callgraph_args[j]; | |
2299 | ||
9b5e350c HM |
2300 | for (j = 1; j < (unsigned int)argc; j++, i++) |
2301 | rec_argv[i] = argv[j]; | |
2302 | ||
2303 | BUG_ON(i != rec_argc); | |
2304 | ||
b0ad8ea6 | 2305 | ret = cmd_record(i, rec_argv); |
0a98c7fe DB |
2306 | free(rec_argv); |
2307 | return ret; | |
9b5e350c HM |
2308 | } |
2309 | ||
ceb13bfc NK |
2310 | static int parse_map_entry(const struct option *opt, const char *str, |
2311 | int unset __maybe_unused) | |
2312 | { | |
2313 | unsigned long *len = (unsigned long *)opt->value; | |
2314 | unsigned long val; | |
2315 | char *endptr; | |
2316 | ||
2317 | errno = 0; | |
2318 | val = strtoul(str, &endptr, 0); | |
2319 | if (*endptr != '\0' || errno != 0) { | |
2320 | pr_err("invalid BPF map length: %s\n", str); | |
2321 | return -1; | |
2322 | } | |
2323 | ||
2324 | *len = val; | |
2325 | return 0; | |
2326 | } | |
2327 | ||
0a277b62 NK |
2328 | static int parse_max_stack(const struct option *opt, const char *str, |
2329 | int unset __maybe_unused) | |
2330 | { | |
2331 | unsigned long *len = (unsigned long *)opt->value; | |
2332 | long val; | |
2333 | char *endptr; | |
2334 | ||
2335 | errno = 0; | |
2336 | val = strtol(str, &endptr, 0); | |
2337 | if (*endptr != '\0' || errno != 0) { | |
2338 | pr_err("invalid max stack depth: %s\n", str); | |
2339 | return -1; | |
2340 | } | |
2341 | ||
2342 | if (val < 0 || val > sysctl__max_stack()) { | |
2343 | pr_err("invalid max stack depth: %ld\n", val); | |
2344 | return -1; | |
2345 | } | |
2346 | ||
2347 | *len = val; | |
2348 | return 0; | |
2349 | } | |
2350 | ||
b4a7eff9 NK |
2351 | static bool add_lock_type(unsigned int flags) |
2352 | { | |
2353 | unsigned int *tmp; | |
2354 | ||
2355 | tmp = realloc(filters.types, (filters.nr_types + 1) * sizeof(*filters.types)); | |
2356 | if (tmp == NULL) | |
2357 | return false; | |
2358 | ||
2359 | tmp[filters.nr_types++] = flags; | |
2360 | filters.types = tmp; | |
2361 | return true; | |
2362 | } | |
2363 | ||
2364 | static int parse_lock_type(const struct option *opt __maybe_unused, const char *str, | |
2365 | int unset __maybe_unused) | |
2366 | { | |
2367 | char *s, *tmp, *tok; | |
2368 | int ret = 0; | |
2369 | ||
2370 | s = strdup(str); | |
2371 | if (s == NULL) | |
2372 | return -1; | |
2373 | ||
2374 | for (tok = strtok_r(s, ", ", &tmp); tok; tok = strtok_r(NULL, ", ", &tmp)) { | |
2375 | unsigned int flags = get_type_flag(tok); | |
2376 | ||
2377 | if (flags == -1U) { | |
d783ea8f NK |
2378 | pr_err("Unknown lock flags: %s\n", tok); |
2379 | ret = -1; | |
2380 | break; | |
b4a7eff9 NK |
2381 | } |
2382 | ||
2383 | if (!add_lock_type(flags)) { | |
2384 | ret = -1; | |
2385 | break; | |
2386 | } | |
b4a7eff9 NK |
2387 | } |
2388 | ||
2389 | free(s); | |
2390 | return ret; | |
2391 | } | |
2392 | ||
511e19b9 NK |
2393 | static bool add_lock_addr(unsigned long addr) |
2394 | { | |
2395 | unsigned long *tmp; | |
2396 | ||
2397 | tmp = realloc(filters.addrs, (filters.nr_addrs + 1) * sizeof(*filters.addrs)); | |
2398 | if (tmp == NULL) { | |
2399 | pr_err("Memory allocation failure\n"); | |
2400 | return false; | |
2401 | } | |
2402 | ||
2403 | tmp[filters.nr_addrs++] = addr; | |
2404 | filters.addrs = tmp; | |
2405 | return true; | |
2406 | } | |
2407 | ||
2408 | static bool add_lock_sym(char *name) | |
2409 | { | |
2410 | char **tmp; | |
2411 | char *sym = strdup(name); | |
2412 | ||
2413 | if (sym == NULL) { | |
2414 | pr_err("Memory allocation failure\n"); | |
2415 | return false; | |
2416 | } | |
2417 | ||
2418 | tmp = realloc(filters.syms, (filters.nr_syms + 1) * sizeof(*filters.syms)); | |
2419 | if (tmp == NULL) { | |
2420 | pr_err("Memory allocation failure\n"); | |
2421 | free(sym); | |
2422 | return false; | |
2423 | } | |
2424 | ||
2425 | tmp[filters.nr_syms++] = sym; | |
2426 | filters.syms = tmp; | |
2427 | return true; | |
2428 | } | |
2429 | ||
2430 | static int parse_lock_addr(const struct option *opt __maybe_unused, const char *str, | |
2431 | int unset __maybe_unused) | |
2432 | { | |
2433 | char *s, *tmp, *tok; | |
2434 | int ret = 0; | |
2435 | u64 addr; | |
2436 | ||
2437 | s = strdup(str); | |
2438 | if (s == NULL) | |
2439 | return -1; | |
2440 | ||
2441 | for (tok = strtok_r(s, ", ", &tmp); tok; tok = strtok_r(NULL, ", ", &tmp)) { | |
2442 | char *end; | |
2443 | ||
2444 | addr = strtoul(tok, &end, 16); | |
2445 | if (*end == '\0') { | |
2446 | if (!add_lock_addr(addr)) { | |
2447 | ret = -1; | |
2448 | break; | |
2449 | } | |
2450 | continue; | |
2451 | } | |
2452 | ||
2453 | /* | |
2454 | * At this moment, we don't have kernel symbols. Save the symbols | |
2455 | * in a separate list and resolve them to addresses later. | |
2456 | */ | |
2457 | if (!add_lock_sym(tok)) { | |
2458 | ret = -1; | |
2459 | break; | |
2460 | } | |
2461 | } | |
2462 | ||
2463 | free(s); | |
2464 | return ret; | |
2465 | } | |
2466 | ||
7b204399 NK |
2467 | static int parse_call_stack(const struct option *opt __maybe_unused, const char *str, |
2468 | int unset __maybe_unused) | |
2469 | { | |
2470 | char *s, *tmp, *tok; | |
2471 | int ret = 0; | |
2472 | ||
2473 | s = strdup(str); | |
2474 | if (s == NULL) | |
2475 | return -1; | |
2476 | ||
2477 | for (tok = strtok_r(s, ", ", &tmp); tok; tok = strtok_r(NULL, ", ", &tmp)) { | |
2478 | struct callstack_filter *entry; | |
2479 | ||
2480 | entry = malloc(sizeof(*entry) + strlen(tok) + 1); | |
2481 | if (entry == NULL) { | |
2482 | pr_err("Memory allocation failure\n"); | |
1370406d | 2483 | free(s); |
7b204399 NK |
2484 | return -1; |
2485 | } | |
2486 | ||
2487 | strcpy(entry->name, tok); | |
2488 | list_add_tail(&entry->list, &callstack_filters); | |
2489 | } | |
2490 | ||
2491 | free(s); | |
2492 | return ret; | |
2493 | } | |
2494 | ||
f6027053 NK |
2495 | static int parse_output(const struct option *opt __maybe_unused, const char *str, |
2496 | int unset __maybe_unused) | |
2497 | { | |
2498 | const char **name = (const char **)opt->value; | |
2499 | ||
2500 | if (str == NULL) | |
2501 | return -1; | |
2502 | ||
2503 | lock_output = fopen(str, "w"); | |
2504 | if (lock_output == NULL) { | |
2505 | pr_err("Cannot open %s\n", str); | |
2506 | return -1; | |
2507 | } | |
2508 | ||
2509 | *name = str; | |
2510 | return 0; | |
2511 | } | |
2512 | ||
4fd06bd2 NK |
2513 | static bool add_lock_cgroup(char *name) |
2514 | { | |
2515 | u64 *tmp; | |
2516 | struct cgroup *cgrp; | |
2517 | ||
2518 | cgrp = cgroup__new(name, /*do_open=*/false); | |
2519 | if (cgrp == NULL) { | |
2520 | pr_err("Failed to create cgroup: %s\n", name); | |
2521 | return false; | |
2522 | } | |
2523 | ||
2524 | if (read_cgroup_id(cgrp) < 0) { | |
2525 | pr_err("Failed to read cgroup id for %s\n", name); | |
2526 | cgroup__put(cgrp); | |
2527 | return false; | |
2528 | } | |
2529 | ||
2530 | tmp = realloc(filters.cgrps, (filters.nr_cgrps + 1) * sizeof(*filters.cgrps)); | |
2531 | if (tmp == NULL) { | |
2532 | pr_err("Memory allocation failure\n"); | |
2533 | return false; | |
2534 | } | |
2535 | ||
2536 | tmp[filters.nr_cgrps++] = cgrp->id; | |
2537 | filters.cgrps = tmp; | |
2538 | cgroup__put(cgrp); | |
2539 | return true; | |
2540 | } | |
2541 | ||
2542 | static int parse_cgroup_filter(const struct option *opt __maybe_unused, const char *str, | |
2543 | int unset __maybe_unused) | |
2544 | { | |
2545 | char *s, *tmp, *tok; | |
2546 | int ret = 0; | |
2547 | ||
2548 | s = strdup(str); | |
2549 | if (s == NULL) | |
2550 | return -1; | |
2551 | ||
2552 | for (tok = strtok_r(s, ", ", &tmp); tok; tok = strtok_r(NULL, ", ", &tmp)) { | |
2553 | if (!add_lock_cgroup(tok)) { | |
2554 | ret = -1; | |
2555 | break; | |
2556 | } | |
2557 | } | |
2558 | ||
2559 | free(s); | |
2560 | return ret; | |
2561 | } | |
2562 | ||
b0ad8ea6 | 2563 | int cmd_lock(int argc, const char **argv) |
9b5e350c | 2564 | { |
249eed53 CD |
2565 | const struct option lock_options[] = { |
2566 | OPT_STRING('i', "input", &input_name, "file", "input file name"), | |
f6027053 | 2567 | OPT_CALLBACK(0, "output", &output_name, "file", "output file name", parse_output), |
249eed53 CD |
2568 | OPT_INCR('v', "verbose", &verbose, "be more verbose (show symbol address, etc)"), |
2569 | OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, "dump raw trace in ASCII"), | |
b40e3612 | 2570 | OPT_BOOLEAN('f', "force", &force, "don't complain, do it"), |
309e133d NK |
2571 | OPT_STRING(0, "vmlinux", &symbol_conf.vmlinux_name, |
2572 | "file", "vmlinux pathname"), | |
2573 | OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name, | |
2574 | "file", "kallsyms pathname"), | |
a527c2c1 | 2575 | OPT_BOOLEAN('q', "quiet", &quiet, "Do not show any warnings or messages"), |
249eed53 CD |
2576 | OPT_END() |
2577 | }; | |
2578 | ||
c75d98af ACM |
2579 | const struct option info_options[] = { |
2580 | OPT_BOOLEAN('t', "threads", &info_threads, | |
2581 | "dump thread list in perf.data"), | |
2582 | OPT_BOOLEAN('m', "map", &info_map, | |
2583 | "map of lock instances (address:name table)"), | |
249eed53 | 2584 | OPT_PARENT(lock_options) |
c75d98af | 2585 | }; |
249eed53 | 2586 | |
c75d98af ACM |
2587 | const struct option report_options[] = { |
2588 | OPT_STRING('k', "key", &sort_key, "acquired", | |
f37376cd | 2589 | "key for sorting (acquired / contended / avg_wait / wait_total / wait_max / wait_min)"), |
4bd9cab5 NK |
2590 | OPT_STRING('F', "field", &output_fields, NULL, |
2591 | "output fields (acquired / contended / avg_wait / wait_total / wait_max / wait_min)"), | |
c75d98af | 2592 | /* TODO: type */ |
0d435bf8 NK |
2593 | OPT_BOOLEAN('c', "combine-locks", &combine_locks, |
2594 | "combine locks in the same class"), | |
7c3bcbdf NK |
2595 | OPT_BOOLEAN('t', "threads", &show_thread_stats, |
2596 | "show per-thread lock stats"), | |
6282a1f4 | 2597 | OPT_INTEGER('E', "entries", &print_nr_entries, "display this many functions"), |
249eed53 | 2598 | OPT_PARENT(lock_options) |
c75d98af | 2599 | }; |
249eed53 | 2600 | |
407b36f6 | 2601 | struct option contention_options[] = { |
79079f21 NK |
2602 | OPT_STRING('k', "key", &sort_key, "wait_total", |
2603 | "key for sorting (contended / wait_total / wait_max / wait_min / avg_wait)"), | |
2604 | OPT_STRING('F', "field", &output_fields, "contended,wait_total,wait_max,avg_wait", | |
2605 | "output fields (contended / wait_total / wait_max / wait_min / avg_wait)"), | |
1ab55323 NK |
2606 | OPT_BOOLEAN('t', "threads", &show_thread_stats, |
2607 | "show per-thread lock stats"), | |
407b36f6 | 2608 | OPT_BOOLEAN('b', "use-bpf", &use_bpf, "use BPF program to collect lock contention stats"), |
6fda2405 NK |
2609 | OPT_BOOLEAN('a', "all-cpus", &target.system_wide, |
2610 | "System-wide collection from all CPUs"), | |
2611 | OPT_STRING('C', "cpu", &target.cpu_list, "cpu", | |
2612 | "List of cpus to monitor"), | |
2613 | OPT_STRING('p', "pid", &target.pid, "pid", | |
2614 | "Trace on existing process id"), | |
6fda2405 NK |
2615 | OPT_STRING(0, "tid", &target.tid, "tid", |
2616 | "Trace on existing thread id (exclusive to --pid)"), | |
84b91920 | 2617 | OPT_CALLBACK('M', "map-nr-entries", &bpf_map_entries, "num", |
ceb13bfc | 2618 | "Max number of BPF map entries", parse_map_entry), |
0a277b62 | 2619 | OPT_CALLBACK(0, "max-stack", &max_stack_depth, "num", |
0f2418fd | 2620 | "Set the maximum stack depth when collecting lock contention, " |
0a277b62 | 2621 | "Default: " __stringify(CONTENTION_STACK_DEPTH), parse_max_stack), |
96532a83 NK |
2622 | OPT_INTEGER(0, "stack-skip", &stack_skip, |
2623 | "Set the number of stack depth to skip when finding a lock caller, " | |
2624 | "Default: " __stringify(CONTENTION_STACK_SKIP)), | |
6282a1f4 | 2625 | OPT_INTEGER('E', "entries", &print_nr_entries, "display this many functions"), |
688d2e8d | 2626 | OPT_BOOLEAN('l', "lock-addr", &show_lock_addrs, "show lock stats by address"), |
b4a7eff9 NK |
2627 | OPT_CALLBACK('Y', "type-filter", NULL, "FLAGS", |
2628 | "Filter specific type of locks", parse_lock_type), | |
511e19b9 NK |
2629 | OPT_CALLBACK('L', "lock-filter", NULL, "ADDRS/NAMES", |
2630 | "Filter specific address/symbol of locks", parse_lock_addr), | |
7b204399 NK |
2631 | OPT_CALLBACK('S', "callstack-filter", NULL, "NAMES", |
2632 | "Filter specific function in the callstack", parse_call_stack), | |
3477f079 | 2633 | OPT_BOOLEAN('o', "lock-owner", &show_lock_owner, "show lock owners instead of waiters"), |
69c5c993 NK |
2634 | OPT_STRING_NOEMPTY('x', "field-separator", &symbol_conf.field_sep, "separator", |
2635 | "print result in CSV format with custom separator"), | |
4d1792d0 | 2636 | OPT_BOOLEAN(0, "lock-cgroup", &show_lock_cgroups, "show lock stats by cgroup"), |
4fd06bd2 NK |
2637 | OPT_CALLBACK('G', "cgroup-filter", NULL, "CGROUPS", |
2638 | "Filter specific cgroups", parse_cgroup_filter), | |
528b9cab NK |
2639 | OPT_PARENT(lock_options) |
2640 | }; | |
2641 | ||
c75d98af ACM |
2642 | const char * const info_usage[] = { |
2643 | "perf lock info [<options>]", | |
2644 | NULL | |
2645 | }; | |
a2368c31 | 2646 | const char *const lock_subcommands[] = { "record", "report", "script", |
3705a6ef | 2647 | "info", "contention", NULL }; |
a2368c31 RR |
2648 | const char *lock_usage[] = { |
2649 | NULL, | |
c75d98af ACM |
2650 | NULL |
2651 | }; | |
2652 | const char * const report_usage[] = { | |
2653 | "perf lock report [<options>]", | |
2654 | NULL | |
2655 | }; | |
528b9cab NK |
2656 | const char * const contention_usage[] = { |
2657 | "perf lock contention [<options>]", | |
2658 | NULL | |
2659 | }; | |
9b5e350c | 2660 | unsigned int i; |
33d6aef5 | 2661 | int rc = 0; |
9b5e350c | 2662 | |
eef4fee5 IR |
2663 | lockhash_table = calloc(LOCKHASH_SIZE, sizeof(*lockhash_table)); |
2664 | if (!lockhash_table) | |
2665 | return -ENOMEM; | |
2666 | ||
9b5e350c | 2667 | for (i = 0; i < LOCKHASH_SIZE; i++) |
7672d00a | 2668 | INIT_HLIST_HEAD(lockhash_table + i); |
9b5e350c | 2669 | |
f6027053 | 2670 | lock_output = stderr; |
a2368c31 RR |
2671 | argc = parse_options_subcommand(argc, argv, lock_options, lock_subcommands, |
2672 | lock_usage, PARSE_OPT_STOP_AT_NON_OPTION); | |
9b5e350c HM |
2673 | if (!argc) |
2674 | usage_with_options(lock_usage, lock_options); | |
2675 | ||
ae0f4eb3 | 2676 | if (strlen(argv[0]) > 2 && strstarts("record", argv[0])) { |
9b5e350c | 2677 | return __cmd_record(argc, argv); |
ae0f4eb3 | 2678 | } else if (strlen(argv[0]) > 2 && strstarts("report", argv[0])) { |
59f411b6 | 2679 | trace_handler = &report_lock_ops; |
9b5e350c HM |
2680 | if (argc) { |
2681 | argc = parse_options(argc, argv, | |
59f411b6 | 2682 | report_options, report_usage, 0); |
9b5e350c | 2683 | if (argc) |
59f411b6 | 2684 | usage_with_options(report_usage, report_options); |
9b5e350c | 2685 | } |
375eb2be | 2686 | rc = __cmd_report(false); |
133dc4c3 IM |
2687 | } else if (!strcmp(argv[0], "script")) { |
2688 | /* Aliased to 'perf script' */ | |
eef4fee5 | 2689 | rc = cmd_script(argc, argv); |
26242d85 HM |
2690 | } else if (!strcmp(argv[0], "info")) { |
2691 | if (argc) { | |
2692 | argc = parse_options(argc, argv, | |
2693 | info_options, info_usage, 0); | |
2694 | if (argc) | |
2695 | usage_with_options(info_usage, info_options); | |
2696 | } | |
59f411b6 IM |
2697 | /* recycling report_lock_ops */ |
2698 | trace_handler = &report_lock_ops; | |
375eb2be | 2699 | rc = __cmd_report(true); |
528b9cab NK |
2700 | } else if (strlen(argv[0]) > 2 && strstarts("contention", argv[0])) { |
2701 | trace_handler = &contention_lock_ops; | |
79079f21 NK |
2702 | sort_key = "wait_total"; |
2703 | output_fields = "contended,wait_total,wait_max,avg_wait"; | |
2704 | ||
407b36f6 NK |
2705 | #ifndef HAVE_BPF_SKEL |
2706 | set_option_nobuild(contention_options, 'b', "use-bpf", | |
9a2d5178 | 2707 | "no BUILD_BPF_SKEL=1", false); |
407b36f6 | 2708 | #endif |
528b9cab NK |
2709 | if (argc) { |
2710 | argc = parse_options(argc, argv, contention_options, | |
2711 | contention_usage, 0); | |
528b9cab | 2712 | } |
688d2e8d | 2713 | |
3477f079 NK |
2714 | if (check_lock_contention_options(contention_options, |
2715 | contention_usage) < 0) | |
688d2e8d | 2716 | return -1; |
688d2e8d | 2717 | |
6fda2405 | 2718 | rc = __cmd_contention(argc, argv); |
9b5e350c HM |
2719 | } else { |
2720 | usage_with_options(lock_usage, lock_options); | |
2721 | } | |
2722 | ||
eef4fee5 | 2723 | zfree(&lockhash_table); |
33d6aef5 | 2724 | return rc; |
9b5e350c | 2725 | } |