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