]>
Commit | Line | Data |
---|---|---|
9b5e350c HM |
1 | #include "builtin.h" |
2 | #include "perf.h" | |
3 | ||
746f16ec | 4 | #include "util/evlist.h" |
fcf65bf1 | 5 | #include "util/evsel.h" |
9b5e350c HM |
6 | #include "util/util.h" |
7 | #include "util/cache.h" | |
8 | #include "util/symbol.h" | |
9 | #include "util/thread.h" | |
10 | #include "util/header.h" | |
11 | ||
12 | #include "util/parse-options.h" | |
13 | #include "util/trace-event.h" | |
14 | ||
15 | #include "util/debug.h" | |
16 | #include "util/session.h" | |
45694aa7 | 17 | #include "util/tool.h" |
9b5e350c HM |
18 | |
19 | #include <sys/types.h> | |
20 | #include <sys/prctl.h> | |
21 | #include <semaphore.h> | |
22 | #include <pthread.h> | |
23 | #include <math.h> | |
24 | #include <limits.h> | |
25 | ||
26 | #include <linux/list.h> | |
27 | #include <linux/hash.h> | |
28 | ||
e4cef1f6 HM |
29 | static struct perf_session *session; |
30 | ||
9b5e350c HM |
31 | /* based on kernel/lockdep.c */ |
32 | #define LOCKHASH_BITS 12 | |
33 | #define LOCKHASH_SIZE (1UL << LOCKHASH_BITS) | |
34 | ||
35 | static struct list_head lockhash_table[LOCKHASH_SIZE]; | |
36 | ||
37 | #define __lockhashfn(key) hash_long((unsigned long)key, LOCKHASH_BITS) | |
38 | #define lockhashentry(key) (lockhash_table + __lockhashfn((key))) | |
39 | ||
9b5e350c | 40 | struct lock_stat { |
59f411b6 IM |
41 | struct list_head hash_entry; |
42 | struct rb_node rb; /* used for sorting */ | |
9b5e350c | 43 | |
59f411b6 | 44 | /* |
746f16ec | 45 | * FIXME: perf_evsel__intval() returns u64, |
9b5e350c | 46 | * so address of lockdep_map should be dealed as 64bit. |
59f411b6 IM |
47 | * Is there more better solution? |
48 | */ | |
49 | void *addr; /* address of lockdep_map, used as ID */ | |
50 | char *name; /* for strcpy(), we cannot use const */ | |
9b5e350c | 51 | |
59f411b6 | 52 | unsigned int nr_acquire; |
e4cef1f6 | 53 | unsigned int nr_acquired; |
59f411b6 IM |
54 | unsigned int nr_contended; |
55 | unsigned int nr_release; | |
9b5e350c | 56 | |
e4cef1f6 HM |
57 | unsigned int nr_readlock; |
58 | unsigned int nr_trylock; | |
9b5e350c | 59 | /* these times are in nano sec. */ |
59f411b6 IM |
60 | u64 wait_time_total; |
61 | u64 wait_time_min; | |
62 | u64 wait_time_max; | |
e4cef1f6 HM |
63 | |
64 | int discard; /* flag of blacklist */ | |
65 | }; | |
66 | ||
67 | /* | |
68 | * States of lock_seq_stat | |
69 | * | |
70 | * UNINITIALIZED is required for detecting first event of acquire. | |
71 | * As the nature of lock events, there is no guarantee | |
72 | * that the first event for the locks are acquire, | |
73 | * it can be acquired, contended or release. | |
74 | */ | |
75 | #define SEQ_STATE_UNINITIALIZED 0 /* initial state */ | |
76 | #define SEQ_STATE_RELEASED 1 | |
77 | #define SEQ_STATE_ACQUIRING 2 | |
78 | #define SEQ_STATE_ACQUIRED 3 | |
79 | #define SEQ_STATE_READ_ACQUIRED 4 | |
80 | #define SEQ_STATE_CONTENDED 5 | |
81 | ||
82 | /* | |
83 | * MAX_LOCK_DEPTH | |
84 | * Imported from include/linux/sched.h. | |
85 | * Should this be synchronized? | |
86 | */ | |
87 | #define MAX_LOCK_DEPTH 48 | |
88 | ||
89 | /* | |
90 | * struct lock_seq_stat: | |
91 | * Place to put on state of one lock sequence | |
92 | * 1) acquire -> acquired -> release | |
93 | * 2) acquire -> contended -> acquired -> release | |
94 | * 3) acquire (with read or try) -> release | |
95 | * 4) Are there other patterns? | |
96 | */ | |
97 | struct lock_seq_stat { | |
98 | struct list_head list; | |
99 | int state; | |
100 | u64 prev_event_time; | |
101 | void *addr; | |
102 | ||
103 | int read_count; | |
9b5e350c HM |
104 | }; |
105 | ||
e4cef1f6 HM |
106 | struct thread_stat { |
107 | struct rb_node rb; | |
108 | ||
109 | u32 tid; | |
110 | struct list_head seq_list; | |
111 | }; | |
112 | ||
113 | static struct rb_root thread_stats; | |
114 | ||
115 | static struct thread_stat *thread_stat_find(u32 tid) | |
116 | { | |
117 | struct rb_node *node; | |
118 | struct thread_stat *st; | |
119 | ||
120 | node = thread_stats.rb_node; | |
121 | while (node) { | |
122 | st = container_of(node, struct thread_stat, rb); | |
123 | if (st->tid == tid) | |
124 | return st; | |
125 | else if (tid < st->tid) | |
126 | node = node->rb_left; | |
127 | else | |
128 | node = node->rb_right; | |
129 | } | |
130 | ||
131 | return NULL; | |
132 | } | |
133 | ||
134 | static void thread_stat_insert(struct thread_stat *new) | |
135 | { | |
136 | struct rb_node **rb = &thread_stats.rb_node; | |
137 | struct rb_node *parent = NULL; | |
138 | struct thread_stat *p; | |
139 | ||
140 | while (*rb) { | |
141 | p = container_of(*rb, struct thread_stat, rb); | |
142 | parent = *rb; | |
143 | ||
144 | if (new->tid < p->tid) | |
145 | rb = &(*rb)->rb_left; | |
146 | else if (new->tid > p->tid) | |
147 | rb = &(*rb)->rb_right; | |
148 | else | |
149 | BUG_ON("inserting invalid thread_stat\n"); | |
150 | } | |
151 | ||
152 | rb_link_node(&new->rb, parent, rb); | |
153 | rb_insert_color(&new->rb, &thread_stats); | |
154 | } | |
155 | ||
156 | static struct thread_stat *thread_stat_findnew_after_first(u32 tid) | |
157 | { | |
158 | struct thread_stat *st; | |
159 | ||
160 | st = thread_stat_find(tid); | |
161 | if (st) | |
162 | return st; | |
163 | ||
164 | st = zalloc(sizeof(struct thread_stat)); | |
33d6aef5 DA |
165 | if (!st) { |
166 | pr_err("memory allocation failed\n"); | |
167 | return NULL; | |
168 | } | |
e4cef1f6 HM |
169 | |
170 | st->tid = tid; | |
171 | INIT_LIST_HEAD(&st->seq_list); | |
172 | ||
173 | thread_stat_insert(st); | |
174 | ||
175 | return st; | |
176 | } | |
177 | ||
178 | static struct thread_stat *thread_stat_findnew_first(u32 tid); | |
179 | static struct thread_stat *(*thread_stat_findnew)(u32 tid) = | |
180 | thread_stat_findnew_first; | |
181 | ||
182 | static struct thread_stat *thread_stat_findnew_first(u32 tid) | |
183 | { | |
184 | struct thread_stat *st; | |
185 | ||
186 | st = zalloc(sizeof(struct thread_stat)); | |
33d6aef5 DA |
187 | if (!st) { |
188 | pr_err("memory allocation failed\n"); | |
189 | return NULL; | |
190 | } | |
e4cef1f6 HM |
191 | st->tid = tid; |
192 | INIT_LIST_HEAD(&st->seq_list); | |
193 | ||
194 | rb_link_node(&st->rb, NULL, &thread_stats.rb_node); | |
195 | rb_insert_color(&st->rb, &thread_stats); | |
196 | ||
197 | thread_stat_findnew = thread_stat_findnew_after_first; | |
198 | return st; | |
199 | } | |
200 | ||
9b5e350c | 201 | /* build simple key function one is bigger than two */ |
59f411b6 | 202 | #define SINGLE_KEY(member) \ |
9b5e350c HM |
203 | static int lock_stat_key_ ## member(struct lock_stat *one, \ |
204 | struct lock_stat *two) \ | |
205 | { \ | |
206 | return one->member > two->member; \ | |
207 | } | |
208 | ||
209 | SINGLE_KEY(nr_acquired) | |
210 | SINGLE_KEY(nr_contended) | |
211 | SINGLE_KEY(wait_time_total) | |
9b5e350c HM |
212 | SINGLE_KEY(wait_time_max) |
213 | ||
9df03abe MS |
214 | static int lock_stat_key_wait_time_min(struct lock_stat *one, |
215 | struct lock_stat *two) | |
216 | { | |
217 | u64 s1 = one->wait_time_min; | |
218 | u64 s2 = two->wait_time_min; | |
219 | if (s1 == ULLONG_MAX) | |
220 | s1 = 0; | |
221 | if (s2 == ULLONG_MAX) | |
222 | s2 = 0; | |
223 | return s1 > s2; | |
224 | } | |
225 | ||
9b5e350c HM |
226 | struct lock_key { |
227 | /* | |
228 | * name: the value for specify by user | |
229 | * this should be simpler than raw name of member | |
230 | * e.g. nr_acquired -> acquired, wait_time_total -> wait_total | |
231 | */ | |
59f411b6 IM |
232 | const char *name; |
233 | int (*key)(struct lock_stat*, struct lock_stat*); | |
9b5e350c HM |
234 | }; |
235 | ||
59f411b6 IM |
236 | static const char *sort_key = "acquired"; |
237 | ||
238 | static int (*compare)(struct lock_stat *, struct lock_stat *); | |
239 | ||
240 | static struct rb_root result; /* place to store sorted data */ | |
9b5e350c HM |
241 | |
242 | #define DEF_KEY_LOCK(name, fn_suffix) \ | |
243 | { #name, lock_stat_key_ ## fn_suffix } | |
244 | struct lock_key keys[] = { | |
245 | DEF_KEY_LOCK(acquired, nr_acquired), | |
246 | DEF_KEY_LOCK(contended, nr_contended), | |
247 | DEF_KEY_LOCK(wait_total, wait_time_total), | |
248 | DEF_KEY_LOCK(wait_min, wait_time_min), | |
249 | DEF_KEY_LOCK(wait_max, wait_time_max), | |
250 | ||
251 | /* extra comparisons much complicated should be here */ | |
252 | ||
253 | { NULL, NULL } | |
254 | }; | |
255 | ||
33d6aef5 | 256 | static int select_key(void) |
9b5e350c HM |
257 | { |
258 | int i; | |
259 | ||
260 | for (i = 0; keys[i].name; i++) { | |
261 | if (!strcmp(keys[i].name, sort_key)) { | |
262 | compare = keys[i].key; | |
33d6aef5 | 263 | return 0; |
9b5e350c HM |
264 | } |
265 | } | |
266 | ||
33d6aef5 DA |
267 | pr_err("Unknown compare key: %s\n", sort_key); |
268 | ||
269 | return -1; | |
9b5e350c HM |
270 | } |
271 | ||
9b5e350c | 272 | static void insert_to_result(struct lock_stat *st, |
59f411b6 | 273 | int (*bigger)(struct lock_stat *, struct lock_stat *)) |
9b5e350c HM |
274 | { |
275 | struct rb_node **rb = &result.rb_node; | |
276 | struct rb_node *parent = NULL; | |
277 | struct lock_stat *p; | |
278 | ||
279 | while (*rb) { | |
280 | p = container_of(*rb, struct lock_stat, rb); | |
281 | parent = *rb; | |
282 | ||
283 | if (bigger(st, p)) | |
284 | rb = &(*rb)->rb_left; | |
285 | else | |
286 | rb = &(*rb)->rb_right; | |
287 | } | |
288 | ||
289 | rb_link_node(&st->rb, parent, rb); | |
290 | rb_insert_color(&st->rb, &result); | |
291 | } | |
292 | ||
293 | /* returns left most element of result, and erase it */ | |
294 | static struct lock_stat *pop_from_result(void) | |
295 | { | |
296 | struct rb_node *node = result.rb_node; | |
297 | ||
298 | if (!node) | |
299 | return NULL; | |
300 | ||
301 | while (node->rb_left) | |
302 | node = node->rb_left; | |
303 | ||
304 | rb_erase(node, &result); | |
305 | return container_of(node, struct lock_stat, rb); | |
306 | } | |
307 | ||
59f411b6 | 308 | static struct lock_stat *lock_stat_findnew(void *addr, const char *name) |
9b5e350c HM |
309 | { |
310 | struct list_head *entry = lockhashentry(addr); | |
311 | struct lock_stat *ret, *new; | |
312 | ||
313 | list_for_each_entry(ret, entry, hash_entry) { | |
314 | if (ret->addr == addr) | |
315 | return ret; | |
316 | } | |
317 | ||
318 | new = zalloc(sizeof(struct lock_stat)); | |
319 | if (!new) | |
320 | goto alloc_failed; | |
321 | ||
322 | new->addr = addr; | |
323 | new->name = zalloc(sizeof(char) * strlen(name) + 1); | |
324 | if (!new->name) | |
325 | goto alloc_failed; | |
326 | strcpy(new->name, name); | |
9b5e350c | 327 | |
9b5e350c HM |
328 | new->wait_time_min = ULLONG_MAX; |
329 | ||
330 | list_add(&new->hash_entry, entry); | |
331 | return new; | |
332 | ||
333 | alloc_failed: | |
33d6aef5 DA |
334 | pr_err("memory allocation failed\n"); |
335 | return NULL; | |
9b5e350c HM |
336 | } |
337 | ||
9b5e350c | 338 | struct trace_lock_handler { |
746f16ec ACM |
339 | int (*acquire_event)(struct perf_evsel *evsel, |
340 | struct perf_sample *sample); | |
9b5e350c | 341 | |
746f16ec ACM |
342 | int (*acquired_event)(struct perf_evsel *evsel, |
343 | struct perf_sample *sample); | |
9b5e350c | 344 | |
746f16ec ACM |
345 | int (*contended_event)(struct perf_evsel *evsel, |
346 | struct perf_sample *sample); | |
9b5e350c | 347 | |
746f16ec ACM |
348 | int (*release_event)(struct perf_evsel *evsel, |
349 | struct perf_sample *sample); | |
9b5e350c HM |
350 | }; |
351 | ||
e4cef1f6 HM |
352 | static struct lock_seq_stat *get_seq(struct thread_stat *ts, void *addr) |
353 | { | |
354 | struct lock_seq_stat *seq; | |
355 | ||
356 | list_for_each_entry(seq, &ts->seq_list, list) { | |
357 | if (seq->addr == addr) | |
358 | return seq; | |
359 | } | |
360 | ||
361 | seq = zalloc(sizeof(struct lock_seq_stat)); | |
33d6aef5 DA |
362 | if (!seq) { |
363 | pr_err("memory allocation failed\n"); | |
364 | return NULL; | |
365 | } | |
e4cef1f6 HM |
366 | seq->state = SEQ_STATE_UNINITIALIZED; |
367 | seq->addr = addr; | |
368 | ||
369 | list_add(&seq->list, &ts->seq_list); | |
370 | return seq; | |
371 | } | |
372 | ||
10350ec3 FW |
373 | enum broken_state { |
374 | BROKEN_ACQUIRE, | |
375 | BROKEN_ACQUIRED, | |
376 | BROKEN_CONTENDED, | |
377 | BROKEN_RELEASE, | |
378 | BROKEN_MAX, | |
379 | }; | |
380 | ||
381 | static int bad_hist[BROKEN_MAX]; | |
e4cef1f6 | 382 | |
84c7a217 FW |
383 | enum acquire_flags { |
384 | TRY_LOCK = 1, | |
385 | READ_LOCK = 2, | |
386 | }; | |
387 | ||
746f16ec ACM |
388 | static int report_lock_acquire_event(struct perf_evsel *evsel, |
389 | struct perf_sample *sample) | |
9b5e350c | 390 | { |
746f16ec | 391 | void *addr; |
e4cef1f6 HM |
392 | struct lock_stat *ls; |
393 | struct thread_stat *ts; | |
394 | struct lock_seq_stat *seq; | |
746f16ec ACM |
395 | const char *name = perf_evsel__strval(evsel, sample, "name"); |
396 | u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr"); | |
397 | int flag = perf_evsel__intval(evsel, sample, "flag"); | |
e4cef1f6 | 398 | |
746f16ec ACM |
399 | memcpy(&addr, &tmp, sizeof(void *)); |
400 | ||
401 | ls = lock_stat_findnew(addr, name); | |
33d6aef5 DA |
402 | if (!ls) |
403 | return -1; | |
e4cef1f6 | 404 | if (ls->discard) |
33d6aef5 | 405 | return 0; |
9b5e350c | 406 | |
01d95524 | 407 | ts = thread_stat_findnew(sample->tid); |
33d6aef5 DA |
408 | if (!ts) |
409 | return -1; | |
410 | ||
746f16ec | 411 | seq = get_seq(ts, addr); |
33d6aef5 DA |
412 | if (!seq) |
413 | return -1; | |
9b5e350c | 414 | |
e4cef1f6 HM |
415 | switch (seq->state) { |
416 | case SEQ_STATE_UNINITIALIZED: | |
417 | case SEQ_STATE_RELEASED: | |
746f16ec | 418 | if (!flag) { |
e4cef1f6 HM |
419 | seq->state = SEQ_STATE_ACQUIRING; |
420 | } else { | |
746f16ec | 421 | if (flag & TRY_LOCK) |
e4cef1f6 | 422 | ls->nr_trylock++; |
746f16ec | 423 | if (flag & READ_LOCK) |
e4cef1f6 HM |
424 | ls->nr_readlock++; |
425 | seq->state = SEQ_STATE_READ_ACQUIRED; | |
426 | seq->read_count = 1; | |
427 | ls->nr_acquired++; | |
428 | } | |
429 | break; | |
430 | case SEQ_STATE_READ_ACQUIRED: | |
746f16ec | 431 | if (flag & READ_LOCK) { |
e4cef1f6 HM |
432 | seq->read_count++; |
433 | ls->nr_acquired++; | |
434 | goto end; | |
435 | } else { | |
436 | goto broken; | |
437 | } | |
9b5e350c | 438 | break; |
e4cef1f6 HM |
439 | case SEQ_STATE_ACQUIRED: |
440 | case SEQ_STATE_ACQUIRING: | |
441 | case SEQ_STATE_CONTENDED: | |
442 | broken: | |
443 | /* broken lock sequence, discard it */ | |
444 | ls->discard = 1; | |
10350ec3 | 445 | bad_hist[BROKEN_ACQUIRE]++; |
e4cef1f6 HM |
446 | list_del(&seq->list); |
447 | free(seq); | |
448 | goto end; | |
9b5e350c HM |
449 | break; |
450 | default: | |
e4cef1f6 | 451 | BUG_ON("Unknown state of lock sequence found!\n"); |
9b5e350c HM |
452 | break; |
453 | } | |
454 | ||
e4cef1f6 | 455 | ls->nr_acquire++; |
01d95524 | 456 | seq->prev_event_time = sample->time; |
e4cef1f6 | 457 | end: |
33d6aef5 | 458 | return 0; |
9b5e350c HM |
459 | } |
460 | ||
746f16ec ACM |
461 | static int report_lock_acquired_event(struct perf_evsel *evsel, |
462 | struct perf_sample *sample) | |
9b5e350c | 463 | { |
746f16ec | 464 | void *addr; |
e4cef1f6 HM |
465 | struct lock_stat *ls; |
466 | struct thread_stat *ts; | |
467 | struct lock_seq_stat *seq; | |
468 | u64 contended_term; | |
746f16ec ACM |
469 | const char *name = perf_evsel__strval(evsel, sample, "name"); |
470 | u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr"); | |
471 | ||
472 | memcpy(&addr, &tmp, sizeof(void *)); | |
9b5e350c | 473 | |
746f16ec | 474 | ls = lock_stat_findnew(addr, name); |
33d6aef5 DA |
475 | if (!ls) |
476 | return -1; | |
e4cef1f6 | 477 | if (ls->discard) |
33d6aef5 | 478 | return 0; |
e4cef1f6 | 479 | |
01d95524 | 480 | ts = thread_stat_findnew(sample->tid); |
33d6aef5 DA |
481 | if (!ts) |
482 | return -1; | |
483 | ||
746f16ec | 484 | seq = get_seq(ts, addr); |
33d6aef5 DA |
485 | if (!seq) |
486 | return -1; | |
9b5e350c | 487 | |
e4cef1f6 HM |
488 | switch (seq->state) { |
489 | case SEQ_STATE_UNINITIALIZED: | |
490 | /* orphan event, do nothing */ | |
33d6aef5 | 491 | return 0; |
e4cef1f6 | 492 | case SEQ_STATE_ACQUIRING: |
9b5e350c | 493 | break; |
e4cef1f6 | 494 | case SEQ_STATE_CONTENDED: |
746f16ec | 495 | contended_term = sample->time - seq->prev_event_time; |
e4cef1f6 | 496 | ls->wait_time_total += contended_term; |
e4cef1f6 HM |
497 | if (contended_term < ls->wait_time_min) |
498 | ls->wait_time_min = contended_term; | |
90c0e5fc | 499 | if (ls->wait_time_max < contended_term) |
e4cef1f6 | 500 | ls->wait_time_max = contended_term; |
9b5e350c | 501 | break; |
e4cef1f6 HM |
502 | case SEQ_STATE_RELEASED: |
503 | case SEQ_STATE_ACQUIRED: | |
504 | case SEQ_STATE_READ_ACQUIRED: | |
505 | /* broken lock sequence, discard it */ | |
506 | ls->discard = 1; | |
10350ec3 | 507 | bad_hist[BROKEN_ACQUIRED]++; |
e4cef1f6 HM |
508 | list_del(&seq->list); |
509 | free(seq); | |
510 | goto end; | |
511 | break; | |
512 | ||
9b5e350c | 513 | default: |
e4cef1f6 | 514 | BUG_ON("Unknown state of lock sequence found!\n"); |
9b5e350c HM |
515 | break; |
516 | } | |
517 | ||
e4cef1f6 HM |
518 | seq->state = SEQ_STATE_ACQUIRED; |
519 | ls->nr_acquired++; | |
746f16ec | 520 | seq->prev_event_time = sample->time; |
e4cef1f6 | 521 | end: |
33d6aef5 | 522 | return 0; |
9b5e350c HM |
523 | } |
524 | ||
746f16ec ACM |
525 | static int report_lock_contended_event(struct perf_evsel *evsel, |
526 | struct perf_sample *sample) | |
9b5e350c | 527 | { |
746f16ec | 528 | void *addr; |
e4cef1f6 HM |
529 | struct lock_stat *ls; |
530 | struct thread_stat *ts; | |
531 | struct lock_seq_stat *seq; | |
746f16ec ACM |
532 | const char *name = perf_evsel__strval(evsel, sample, "name"); |
533 | u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr"); | |
534 | ||
535 | memcpy(&addr, &tmp, sizeof(void *)); | |
e4cef1f6 | 536 | |
746f16ec | 537 | ls = lock_stat_findnew(addr, name); |
33d6aef5 DA |
538 | if (!ls) |
539 | return -1; | |
e4cef1f6 | 540 | if (ls->discard) |
33d6aef5 | 541 | return 0; |
9b5e350c | 542 | |
01d95524 | 543 | ts = thread_stat_findnew(sample->tid); |
33d6aef5 DA |
544 | if (!ts) |
545 | return -1; | |
546 | ||
746f16ec | 547 | seq = get_seq(ts, addr); |
33d6aef5 DA |
548 | if (!seq) |
549 | return -1; | |
9b5e350c | 550 | |
e4cef1f6 HM |
551 | switch (seq->state) { |
552 | case SEQ_STATE_UNINITIALIZED: | |
553 | /* orphan event, do nothing */ | |
33d6aef5 | 554 | return 0; |
e4cef1f6 | 555 | case SEQ_STATE_ACQUIRING: |
9b5e350c | 556 | break; |
e4cef1f6 HM |
557 | case SEQ_STATE_RELEASED: |
558 | case SEQ_STATE_ACQUIRED: | |
559 | case SEQ_STATE_READ_ACQUIRED: | |
560 | case SEQ_STATE_CONTENDED: | |
561 | /* broken lock sequence, discard it */ | |
562 | ls->discard = 1; | |
10350ec3 | 563 | bad_hist[BROKEN_CONTENDED]++; |
e4cef1f6 HM |
564 | list_del(&seq->list); |
565 | free(seq); | |
566 | goto end; | |
9b5e350c HM |
567 | break; |
568 | default: | |
e4cef1f6 | 569 | BUG_ON("Unknown state of lock sequence found!\n"); |
9b5e350c HM |
570 | break; |
571 | } | |
572 | ||
e4cef1f6 HM |
573 | seq->state = SEQ_STATE_CONTENDED; |
574 | ls->nr_contended++; | |
01d95524 | 575 | seq->prev_event_time = sample->time; |
e4cef1f6 | 576 | end: |
33d6aef5 | 577 | return 0; |
9b5e350c HM |
578 | } |
579 | ||
746f16ec ACM |
580 | static int report_lock_release_event(struct perf_evsel *evsel, |
581 | struct perf_sample *sample) | |
9b5e350c | 582 | { |
746f16ec | 583 | void *addr; |
e4cef1f6 HM |
584 | struct lock_stat *ls; |
585 | struct thread_stat *ts; | |
586 | struct lock_seq_stat *seq; | |
746f16ec ACM |
587 | const char *name = perf_evsel__strval(evsel, sample, "name"); |
588 | u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr"); | |
9b5e350c | 589 | |
746f16ec ACM |
590 | memcpy(&addr, &tmp, sizeof(void *)); |
591 | ||
592 | ls = lock_stat_findnew(addr, name); | |
33d6aef5 DA |
593 | if (!ls) |
594 | return -1; | |
e4cef1f6 | 595 | if (ls->discard) |
33d6aef5 | 596 | return 0; |
9b5e350c | 597 | |
01d95524 | 598 | ts = thread_stat_findnew(sample->tid); |
33d6aef5 DA |
599 | if (!ts) |
600 | return -1; | |
601 | ||
746f16ec | 602 | seq = get_seq(ts, addr); |
33d6aef5 DA |
603 | if (!seq) |
604 | return -1; | |
9b5e350c | 605 | |
e4cef1f6 HM |
606 | switch (seq->state) { |
607 | case SEQ_STATE_UNINITIALIZED: | |
608 | goto end; | |
609 | break; | |
610 | case SEQ_STATE_ACQUIRED: | |
611 | break; | |
612 | case SEQ_STATE_READ_ACQUIRED: | |
613 | seq->read_count--; | |
614 | BUG_ON(seq->read_count < 0); | |
615 | if (!seq->read_count) { | |
616 | ls->nr_release++; | |
9b5e350c HM |
617 | goto end; |
618 | } | |
e4cef1f6 HM |
619 | break; |
620 | case SEQ_STATE_ACQUIRING: | |
621 | case SEQ_STATE_CONTENDED: | |
622 | case SEQ_STATE_RELEASED: | |
623 | /* broken lock sequence, discard it */ | |
624 | ls->discard = 1; | |
10350ec3 | 625 | bad_hist[BROKEN_RELEASE]++; |
e4cef1f6 | 626 | goto free_seq; |
9b5e350c HM |
627 | break; |
628 | default: | |
e4cef1f6 | 629 | BUG_ON("Unknown state of lock sequence found!\n"); |
9b5e350c HM |
630 | break; |
631 | } | |
632 | ||
e4cef1f6 HM |
633 | ls->nr_release++; |
634 | free_seq: | |
635 | list_del(&seq->list); | |
636 | free(seq); | |
9b5e350c | 637 | end: |
33d6aef5 | 638 | return 0; |
9b5e350c HM |
639 | } |
640 | ||
641 | /* lock oriented handlers */ | |
642 | /* TODO: handlers for CPU oriented, thread oriented */ | |
59f411b6 IM |
643 | static struct trace_lock_handler report_lock_ops = { |
644 | .acquire_event = report_lock_acquire_event, | |
645 | .acquired_event = report_lock_acquired_event, | |
646 | .contended_event = report_lock_contended_event, | |
647 | .release_event = report_lock_release_event, | |
9b5e350c HM |
648 | }; |
649 | ||
650 | static struct trace_lock_handler *trace_handler; | |
651 | ||
33d6aef5 | 652 | static int perf_evsel__process_lock_acquire(struct perf_evsel *evsel, |
01d95524 | 653 | struct perf_sample *sample) |
9b5e350c | 654 | { |
59f411b6 | 655 | if (trace_handler->acquire_event) |
746f16ec ACM |
656 | return trace_handler->acquire_event(evsel, sample); |
657 | return 0; | |
9b5e350c HM |
658 | } |
659 | ||
33d6aef5 | 660 | static int perf_evsel__process_lock_acquired(struct perf_evsel *evsel, |
01d95524 | 661 | struct perf_sample *sample) |
9b5e350c | 662 | { |
33d6aef5 | 663 | if (trace_handler->acquired_event) |
746f16ec ACM |
664 | return trace_handler->acquired_event(evsel, sample); |
665 | return 0; | |
9b5e350c HM |
666 | } |
667 | ||
33d6aef5 | 668 | static int perf_evsel__process_lock_contended(struct perf_evsel *evsel, |
746f16ec | 669 | struct perf_sample *sample) |
9b5e350c | 670 | { |
33d6aef5 | 671 | if (trace_handler->contended_event) |
746f16ec ACM |
672 | return trace_handler->contended_event(evsel, sample); |
673 | return 0; | |
9b5e350c HM |
674 | } |
675 | ||
33d6aef5 | 676 | static int perf_evsel__process_lock_release(struct perf_evsel *evsel, |
746f16ec | 677 | struct perf_sample *sample) |
9b5e350c | 678 | { |
33d6aef5 | 679 | if (trace_handler->release_event) |
746f16ec ACM |
680 | return trace_handler->release_event(evsel, sample); |
681 | return 0; | |
9b5e350c HM |
682 | } |
683 | ||
10350ec3 FW |
684 | static void print_bad_events(int bad, int total) |
685 | { | |
686 | /* Output for debug, this have to be removed */ | |
687 | int i; | |
688 | const char *name[4] = | |
689 | { "acquire", "acquired", "contended", "release" }; | |
690 | ||
691 | pr_info("\n=== output for debug===\n\n"); | |
5efe08cf FW |
692 | pr_info("bad: %d, total: %d\n", bad, total); |
693 | pr_info("bad rate: %f %%\n", (double)bad / (double)total * 100); | |
10350ec3 FW |
694 | pr_info("histogram of events caused bad sequence\n"); |
695 | for (i = 0; i < BROKEN_MAX; i++) | |
696 | pr_info(" %10s: %d\n", name[i], bad_hist[i]); | |
697 | } | |
698 | ||
9b5e350c HM |
699 | /* TODO: various way to print, coloring, nano or milli sec */ |
700 | static void print_result(void) | |
701 | { | |
702 | struct lock_stat *st; | |
703 | char cut_name[20]; | |
e4cef1f6 | 704 | int bad, total; |
9b5e350c | 705 | |
26242d85 HM |
706 | pr_info("%20s ", "Name"); |
707 | pr_info("%10s ", "acquired"); | |
708 | pr_info("%10s ", "contended"); | |
9b5e350c | 709 | |
26242d85 HM |
710 | pr_info("%15s ", "total wait (ns)"); |
711 | pr_info("%15s ", "max wait (ns)"); | |
712 | pr_info("%15s ", "min wait (ns)"); | |
9b5e350c | 713 | |
26242d85 | 714 | pr_info("\n\n"); |
9b5e350c | 715 | |
e4cef1f6 | 716 | bad = total = 0; |
9b5e350c | 717 | while ((st = pop_from_result())) { |
e4cef1f6 HM |
718 | total++; |
719 | if (st->discard) { | |
720 | bad++; | |
721 | continue; | |
722 | } | |
9b5e350c HM |
723 | bzero(cut_name, 20); |
724 | ||
9b5e350c HM |
725 | if (strlen(st->name) < 16) { |
726 | /* output raw name */ | |
26242d85 | 727 | pr_info("%20s ", st->name); |
9b5e350c HM |
728 | } else { |
729 | strncpy(cut_name, st->name, 16); | |
730 | cut_name[16] = '.'; | |
731 | cut_name[17] = '.'; | |
732 | cut_name[18] = '.'; | |
733 | cut_name[19] = '\0'; | |
734 | /* cut off name for saving output style */ | |
26242d85 | 735 | pr_info("%20s ", cut_name); |
9b5e350c HM |
736 | } |
737 | ||
26242d85 HM |
738 | pr_info("%10u ", st->nr_acquired); |
739 | pr_info("%10u ", st->nr_contended); | |
9b5e350c | 740 | |
9486aa38 ACM |
741 | pr_info("%15" PRIu64 " ", st->wait_time_total); |
742 | pr_info("%15" PRIu64 " ", st->wait_time_max); | |
743 | pr_info("%15" PRIu64 " ", st->wait_time_min == ULLONG_MAX ? | |
9b5e350c | 744 | 0 : st->wait_time_min); |
26242d85 | 745 | pr_info("\n"); |
9b5e350c | 746 | } |
e4cef1f6 | 747 | |
10350ec3 | 748 | print_bad_events(bad, total); |
9b5e350c HM |
749 | } |
750 | ||
8035458f | 751 | static bool info_threads, info_map; |
26242d85 HM |
752 | |
753 | static void dump_threads(void) | |
754 | { | |
755 | struct thread_stat *st; | |
756 | struct rb_node *node; | |
757 | struct thread *t; | |
758 | ||
759 | pr_info("%10s: comm\n", "Thread ID"); | |
760 | ||
761 | node = rb_first(&thread_stats); | |
762 | while (node) { | |
763 | st = container_of(node, struct thread_stat, rb); | |
764 | t = perf_session__findnew(session, st->tid); | |
765 | pr_info("%10d: %s\n", st->tid, t->comm); | |
766 | node = rb_next(node); | |
767 | }; | |
768 | } | |
769 | ||
9b5e350c HM |
770 | static void dump_map(void) |
771 | { | |
772 | unsigned int i; | |
773 | struct lock_stat *st; | |
774 | ||
26242d85 | 775 | pr_info("Address of instance: name of class\n"); |
9b5e350c HM |
776 | for (i = 0; i < LOCKHASH_SIZE; i++) { |
777 | list_for_each_entry(st, &lockhash_table[i], hash_entry) { | |
26242d85 | 778 | pr_info(" %p: %s\n", st->addr, st->name); |
9b5e350c HM |
779 | } |
780 | } | |
781 | } | |
782 | ||
33d6aef5 | 783 | static int dump_info(void) |
26242d85 | 784 | { |
33d6aef5 DA |
785 | int rc = 0; |
786 | ||
26242d85 HM |
787 | if (info_threads) |
788 | dump_threads(); | |
789 | else if (info_map) | |
790 | dump_map(); | |
33d6aef5 DA |
791 | else { |
792 | rc = -1; | |
793 | pr_err("Unknown type of information\n"); | |
794 | } | |
795 | ||
796 | return rc; | |
26242d85 HM |
797 | } |
798 | ||
746f16ec ACM |
799 | typedef int (*tracepoint_handler)(struct perf_evsel *evsel, |
800 | struct perf_sample *sample); | |
801 | ||
1d037ca1 | 802 | static int process_sample_event(struct perf_tool *tool __maybe_unused, |
d20deb64 | 803 | union perf_event *event, |
9e69c210 | 804 | struct perf_sample *sample, |
fcf65bf1 | 805 | struct perf_evsel *evsel, |
743eb868 | 806 | struct machine *machine) |
c61e52ee | 807 | { |
743eb868 | 808 | struct thread *thread = machine__findnew_thread(machine, sample->tid); |
c61e52ee | 809 | |
c61e52ee FW |
810 | if (thread == NULL) { |
811 | pr_debug("problem processing %d event, skipping it.\n", | |
8115d60c | 812 | event->header.type); |
c61e52ee FW |
813 | return -1; |
814 | } | |
815 | ||
746f16ec ACM |
816 | if (evsel->handler.func != NULL) { |
817 | tracepoint_handler f = evsel->handler.func; | |
818 | return f(evsel, sample); | |
819 | } | |
820 | ||
821 | return 0; | |
c61e52ee FW |
822 | } |
823 | ||
746f16ec ACM |
824 | static const struct perf_evsel_str_handler lock_tracepoints[] = { |
825 | { "lock:lock_acquire", perf_evsel__process_lock_acquire, }, /* CONFIG_LOCKDEP */ | |
826 | { "lock:lock_acquired", perf_evsel__process_lock_acquired, }, /* CONFIG_LOCKDEP, CONFIG_LOCK_STAT */ | |
827 | { "lock:lock_contended", perf_evsel__process_lock_contended, }, /* CONFIG_LOCKDEP, CONFIG_LOCK_STAT */ | |
828 | { "lock:lock_release", perf_evsel__process_lock_release, }, /* CONFIG_LOCKDEP */ | |
829 | }; | |
830 | ||
9b5e350c HM |
831 | static int read_events(void) |
832 | { | |
c75d98af ACM |
833 | struct perf_tool eops = { |
834 | .sample = process_sample_event, | |
835 | .comm = perf_event__process_comm, | |
836 | .ordered_samples = true, | |
837 | }; | |
21ef97f0 | 838 | session = perf_session__new(input_name, O_RDONLY, 0, false, &eops); |
33d6aef5 DA |
839 | if (!session) { |
840 | pr_err("Initializing perf session failed\n"); | |
841 | return -1; | |
842 | } | |
9b5e350c | 843 | |
746f16ec ACM |
844 | if (perf_session__set_tracepoints_handlers(session, lock_tracepoints)) { |
845 | pr_err("Initializing perf session tracepoint handlers failed\n"); | |
846 | return -1; | |
847 | } | |
848 | ||
9b5e350c HM |
849 | return perf_session__process_events(session, &eops); |
850 | } | |
851 | ||
852 | static void sort_result(void) | |
853 | { | |
854 | unsigned int i; | |
855 | struct lock_stat *st; | |
856 | ||
857 | for (i = 0; i < LOCKHASH_SIZE; i++) { | |
858 | list_for_each_entry(st, &lockhash_table[i], hash_entry) { | |
859 | insert_to_result(st, compare); | |
860 | } | |
861 | } | |
862 | } | |
863 | ||
33d6aef5 | 864 | static int __cmd_report(void) |
9b5e350c HM |
865 | { |
866 | setup_pager(); | |
33d6aef5 DA |
867 | |
868 | if ((select_key() != 0) || | |
869 | (read_events() != 0)) | |
870 | return -1; | |
871 | ||
9b5e350c HM |
872 | sort_result(); |
873 | print_result(); | |
33d6aef5 DA |
874 | |
875 | return 0; | |
9b5e350c HM |
876 | } |
877 | ||
9b5e350c HM |
878 | static int __cmd_record(int argc, const char **argv) |
879 | { | |
c75d98af | 880 | const char *record_args[] = { |
4a4d371a | 881 | "record", "-R", "-m", "1024", "-c", "1", |
c75d98af | 882 | }; |
9b5e350c HM |
883 | unsigned int rec_argc, i, j; |
884 | const char **rec_argv; | |
885 | ||
d25dcba8 | 886 | for (i = 0; i < ARRAY_SIZE(lock_tracepoints); i++) { |
746f16ec | 887 | if (!is_valid_tracepoint(lock_tracepoints[i].name)) { |
d25dcba8 DA |
888 | pr_err("tracepoint %s is not enabled. " |
889 | "Are CONFIG_LOCKDEP and CONFIG_LOCK_STAT enabled?\n", | |
746f16ec | 890 | lock_tracepoints[i].name); |
d25dcba8 DA |
891 | return 1; |
892 | } | |
893 | } | |
894 | ||
9b5e350c | 895 | rec_argc = ARRAY_SIZE(record_args) + argc - 1; |
d25dcba8 DA |
896 | /* factor of 2 is for -e in front of each tracepoint */ |
897 | rec_argc += 2 * ARRAY_SIZE(lock_tracepoints); | |
9b5e350c | 898 | |
d25dcba8 | 899 | rec_argv = calloc(rec_argc + 1, sizeof(char *)); |
ce47dc56 CS |
900 | if (rec_argv == NULL) |
901 | return -ENOMEM; | |
902 | ||
9b5e350c HM |
903 | for (i = 0; i < ARRAY_SIZE(record_args); i++) |
904 | rec_argv[i] = strdup(record_args[i]); | |
905 | ||
d25dcba8 DA |
906 | for (j = 0; j < ARRAY_SIZE(lock_tracepoints); j++) { |
907 | rec_argv[i++] = "-e"; | |
746f16ec | 908 | rec_argv[i++] = strdup(lock_tracepoints[j].name); |
d25dcba8 DA |
909 | } |
910 | ||
9b5e350c HM |
911 | for (j = 1; j < (unsigned int)argc; j++, i++) |
912 | rec_argv[i] = argv[j]; | |
913 | ||
914 | BUG_ON(i != rec_argc); | |
915 | ||
916 | return cmd_record(i, rec_argv, NULL); | |
917 | } | |
918 | ||
1d037ca1 | 919 | int cmd_lock(int argc, const char **argv, const char *prefix __maybe_unused) |
9b5e350c | 920 | { |
c75d98af ACM |
921 | const struct option info_options[] = { |
922 | OPT_BOOLEAN('t', "threads", &info_threads, | |
923 | "dump thread list in perf.data"), | |
924 | OPT_BOOLEAN('m', "map", &info_map, | |
925 | "map of lock instances (address:name table)"), | |
926 | OPT_END() | |
927 | }; | |
928 | const struct option lock_options[] = { | |
929 | OPT_STRING('i', "input", &input_name, "file", "input file name"), | |
930 | OPT_INCR('v', "verbose", &verbose, "be more verbose (show symbol address, etc)"), | |
931 | OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, "dump raw trace in ASCII"), | |
932 | OPT_END() | |
933 | }; | |
934 | const struct option report_options[] = { | |
935 | OPT_STRING('k', "key", &sort_key, "acquired", | |
936 | "key for sorting (acquired / contended / wait_total / wait_max / wait_min)"), | |
937 | /* TODO: type */ | |
938 | OPT_END() | |
939 | }; | |
940 | const char * const info_usage[] = { | |
941 | "perf lock info [<options>]", | |
942 | NULL | |
943 | }; | |
944 | const char * const lock_usage[] = { | |
945 | "perf lock [<options>] {record|report|script|info}", | |
946 | NULL | |
947 | }; | |
948 | const char * const report_usage[] = { | |
949 | "perf lock report [<options>]", | |
950 | NULL | |
951 | }; | |
9b5e350c | 952 | unsigned int i; |
33d6aef5 | 953 | int rc = 0; |
9b5e350c HM |
954 | |
955 | symbol__init(); | |
956 | for (i = 0; i < LOCKHASH_SIZE; i++) | |
957 | INIT_LIST_HEAD(lockhash_table + i); | |
958 | ||
959 | argc = parse_options(argc, argv, lock_options, lock_usage, | |
960 | PARSE_OPT_STOP_AT_NON_OPTION); | |
961 | if (!argc) | |
962 | usage_with_options(lock_usage, lock_options); | |
963 | ||
964 | if (!strncmp(argv[0], "rec", 3)) { | |
965 | return __cmd_record(argc, argv); | |
59f411b6 IM |
966 | } else if (!strncmp(argv[0], "report", 6)) { |
967 | trace_handler = &report_lock_ops; | |
9b5e350c HM |
968 | if (argc) { |
969 | argc = parse_options(argc, argv, | |
59f411b6 | 970 | report_options, report_usage, 0); |
9b5e350c | 971 | if (argc) |
59f411b6 | 972 | usage_with_options(report_usage, report_options); |
9b5e350c | 973 | } |
59f411b6 | 974 | __cmd_report(); |
133dc4c3 IM |
975 | } else if (!strcmp(argv[0], "script")) { |
976 | /* Aliased to 'perf script' */ | |
977 | return cmd_script(argc, argv, prefix); | |
26242d85 HM |
978 | } else if (!strcmp(argv[0], "info")) { |
979 | if (argc) { | |
980 | argc = parse_options(argc, argv, | |
981 | info_options, info_usage, 0); | |
982 | if (argc) | |
983 | usage_with_options(info_usage, info_options); | |
984 | } | |
59f411b6 IM |
985 | /* recycling report_lock_ops */ |
986 | trace_handler = &report_lock_ops; | |
9b5e350c | 987 | setup_pager(); |
33d6aef5 DA |
988 | if (read_events() != 0) |
989 | rc = -1; | |
990 | else | |
991 | rc = dump_info(); | |
9b5e350c HM |
992 | } else { |
993 | usage_with_options(lock_usage, lock_options); | |
994 | } | |
995 | ||
33d6aef5 | 996 | return rc; |
9b5e350c | 997 | } |