1#include "builtin.h" 2#include "perf.h" 3 4#include "util/evlist.h" 5#include "util/evsel.h" 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" 17#include "util/tool.h" 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 29static struct perf_session *session; 30 31/* based on kernel/lockdep.c */ 32#define LOCKHASH_BITS 12 33#define LOCKHASH_SIZE (1UL << LOCKHASH_BITS) 34 35static 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 40struct lock_stat { 41 struct list_head hash_entry; 42 struct rb_node rb; /* used for sorting */ 43 44 /* 45 * FIXME: perf_evsel__intval() returns u64, 46 * so address of lockdep_map should be dealed as 64bit. 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 */ 51 52 unsigned int nr_acquire; 53 unsigned int nr_acquired; 54 unsigned int nr_contended; 55 unsigned int nr_release; 56 57 unsigned int nr_readlock; 58 unsigned int nr_trylock; 59 /* these times are in nano sec. */ 60 u64 wait_time_total; 61 u64 wait_time_min; 62 u64 wait_time_max; 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 */ 97struct lock_seq_stat { 98 struct list_head list; 99 int state; 100 u64 prev_event_time; 101 void *addr; 102 103 int read_count; 104}; 105 106struct thread_stat { 107 struct rb_node rb; 108 109 u32 tid; 110 struct list_head seq_list; 111}; 112 113static struct rb_root thread_stats; 114 115static 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 134static 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 156static 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)); 165 if (!st) { 166 pr_err("memory allocation failed\n"); 167 return NULL; 168 } 169 170 st->tid = tid; 171 INIT_LIST_HEAD(&st->seq_list); 172 173 thread_stat_insert(st); 174 175 return st; 176} 177 178static struct thread_stat *thread_stat_findnew_first(u32 tid); 179static struct thread_stat *(*thread_stat_findnew)(u32 tid) = 180 thread_stat_findnew_first; 181 182static struct thread_stat *thread_stat_findnew_first(u32 tid) 183{ 184 struct thread_stat *st; 185 186 st = zalloc(sizeof(struct thread_stat)); 187 if (!st) { 188 pr_err("memory allocation failed\n"); 189 return NULL; 190 } 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 201/* build simple key function one is bigger than two */ 202#define SINGLE_KEY(member) \ 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 209SINGLE_KEY(nr_acquired) 210SINGLE_KEY(nr_contended) 211SINGLE_KEY(wait_time_total) 212SINGLE_KEY(wait_time_max) 213 214static 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 226struct 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 */ 232 const char *name; 233 int (*key)(struct lock_stat*, struct lock_stat*); 234}; 235 236static const char *sort_key = "acquired"; 237 238static int (*compare)(struct lock_stat *, struct lock_stat *); 239 240static struct rb_root result; /* place to store sorted data */ 241 242#define DEF_KEY_LOCK(name, fn_suffix) \ 243 { #name, lock_stat_key_ ## fn_suffix } 244struct 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 256static int select_key(void) 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; 263 return 0; 264 } 265 } 266 267 pr_err("Unknown compare key: %s\n", sort_key); 268 269 return -1; 270} 271 272static void insert_to_result(struct lock_stat *st, 273 int (*bigger)(struct lock_stat *, struct lock_stat *)) 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 */ 294static 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 308static struct lock_stat *lock_stat_findnew(void *addr, const char *name) 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); 327 328 new->wait_time_min = ULLONG_MAX; 329 330 list_add(&new->hash_entry, entry); 331 return new; 332 333alloc_failed: 334 pr_err("memory allocation failed\n"); 335 return NULL; 336} 337 338struct trace_lock_handler { 339 int (*acquire_event)(struct perf_evsel *evsel, 340 struct perf_sample *sample); 341 342 int (*acquired_event)(struct perf_evsel *evsel, 343 struct perf_sample *sample); 344 345 int (*contended_event)(struct perf_evsel *evsel, 346 struct perf_sample *sample); 347 348 int (*release_event)(struct perf_evsel *evsel, 349 struct perf_sample *sample); 350}; 351 352static 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)); 362 if (!seq) { 363 pr_err("memory allocation failed\n"); 364 return NULL; 365 } 366 seq->state = SEQ_STATE_UNINITIALIZED; 367 seq->addr = addr; 368 369 list_add(&seq->list, &ts->seq_list); 370 return seq; 371} 372 373enum broken_state { 374 BROKEN_ACQUIRE, 375 BROKEN_ACQUIRED, 376 BROKEN_CONTENDED, 377 BROKEN_RELEASE, 378 BROKEN_MAX, 379}; 380 381static int bad_hist[BROKEN_MAX]; 382 383enum acquire_flags { 384 TRY_LOCK = 1, 385 READ_LOCK = 2, 386}; 387 388static int report_lock_acquire_event(struct perf_evsel *evsel, 389 struct perf_sample *sample) 390{ 391 void *addr; 392 struct lock_stat *ls; 393 struct thread_stat *ts; 394 struct lock_seq_stat *seq; 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"); 398 399 memcpy(&addr, &tmp, sizeof(void *)); 400 401 ls = lock_stat_findnew(addr, name); 402 if (!ls) 403 return -1; 404 if (ls->discard) 405 return 0; 406 407 ts = thread_stat_findnew(sample->tid); 408 if (!ts) 409 return -1; 410 411 seq = get_seq(ts, addr); 412 if (!seq) 413 return -1; 414 415 switch (seq->state) { 416 case SEQ_STATE_UNINITIALIZED: 417 case SEQ_STATE_RELEASED: 418 if (!flag) { 419 seq->state = SEQ_STATE_ACQUIRING; 420 } else { 421 if (flag & TRY_LOCK) 422 ls->nr_trylock++; 423 if (flag & READ_LOCK) 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: 431 if (flag & READ_LOCK) { 432 seq->read_count++; 433 ls->nr_acquired++; 434 goto end; 435 } else { 436 goto broken; 437 } 438 break; 439 case SEQ_STATE_ACQUIRED: 440 case SEQ_STATE_ACQUIRING: 441 case SEQ_STATE_CONTENDED: 442broken: 443 /* broken lock sequence, discard it */ 444 ls->discard = 1; 445 bad_hist[BROKEN_ACQUIRE]++; 446 list_del(&seq->list); 447 free(seq); 448 goto end; 449 break; 450 default: 451 BUG_ON("Unknown state of lock sequence found!\n"); 452 break; 453 } 454 455 ls->nr_acquire++; 456 seq->prev_event_time = sample->time; 457end: 458 return 0; 459} 460 461static int report_lock_acquired_event(struct perf_evsel *evsel, 462 struct perf_sample *sample) 463{ 464 void *addr; 465 struct lock_stat *ls; 466 struct thread_stat *ts; 467 struct lock_seq_stat *seq; 468 u64 contended_term; 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 *)); 473 474 ls = lock_stat_findnew(addr, name); 475 if (!ls) 476 return -1; 477 if (ls->discard) 478 return 0; 479 480 ts = thread_stat_findnew(sample->tid); 481 if (!ts) 482 return -1; 483 484 seq = get_seq(ts, addr); 485 if (!seq) 486 return -1; 487 488 switch (seq->state) { 489 case SEQ_STATE_UNINITIALIZED: 490 /* orphan event, do nothing */ 491 return 0; 492 case SEQ_STATE_ACQUIRING: 493 break; 494 case SEQ_STATE_CONTENDED: 495 contended_term = sample->time - seq->prev_event_time; 496 ls->wait_time_total += contended_term; 497 if (contended_term < ls->wait_time_min) 498 ls->wait_time_min = contended_term; 499 if (ls->wait_time_max < contended_term) 500 ls->wait_time_max = contended_term; 501 break; 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; 507 bad_hist[BROKEN_ACQUIRED]++; 508 list_del(&seq->list); 509 free(seq); 510 goto end; 511 break; 512 513 default: 514 BUG_ON("Unknown state of lock sequence found!\n"); 515 break; 516 } 517 518 seq->state = SEQ_STATE_ACQUIRED; 519 ls->nr_acquired++; 520 seq->prev_event_time = sample->time; 521end: 522 return 0; 523} 524 525static int report_lock_contended_event(struct perf_evsel *evsel, 526 struct perf_sample *sample) 527{ 528 void *addr; 529 struct lock_stat *ls; 530 struct thread_stat *ts; 531 struct lock_seq_stat *seq; 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 *)); 536 537 ls = lock_stat_findnew(addr, name); 538 if (!ls) 539 return -1; 540 if (ls->discard) 541 return 0; 542 543 ts = thread_stat_findnew(sample->tid); 544 if (!ts) 545 return -1; 546 547 seq = get_seq(ts, addr); 548 if (!seq) 549 return -1; 550 551 switch (seq->state) { 552 case SEQ_STATE_UNINITIALIZED: 553 /* orphan event, do nothing */ 554 return 0; 555 case SEQ_STATE_ACQUIRING: 556 break; 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; 563 bad_hist[BROKEN_CONTENDED]++; 564 list_del(&seq->list); 565 free(seq); 566 goto end; 567 break; 568 default: 569 BUG_ON("Unknown state of lock sequence found!\n"); 570 break; 571 } 572 573 seq->state = SEQ_STATE_CONTENDED; 574 ls->nr_contended++; 575 seq->prev_event_time = sample->time; 576end: 577 return 0; 578} 579 580static int report_lock_release_event(struct perf_evsel *evsel, 581 struct perf_sample *sample) 582{ 583 void *addr; 584 struct lock_stat *ls; 585 struct thread_stat *ts; 586 struct lock_seq_stat *seq; 587 const char *name = perf_evsel__strval(evsel, sample, "name"); 588 u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr"); 589 590 memcpy(&addr, &tmp, sizeof(void *)); 591 592 ls = lock_stat_findnew(addr, name); 593 if (!ls) 594 return -1; 595 if (ls->discard) 596 return 0; 597 598 ts = thread_stat_findnew(sample->tid); 599 if (!ts) 600 return -1; 601 602 seq = get_seq(ts, addr); 603 if (!seq) 604 return -1; 605 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++; 617 goto end; 618 } 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; 625 bad_hist[BROKEN_RELEASE]++; 626 goto free_seq; 627 break; 628 default: 629 BUG_ON("Unknown state of lock sequence found!\n"); 630 break; 631 } 632 633 ls->nr_release++; 634free_seq: 635 list_del(&seq->list); 636 free(seq); 637end: 638 return 0; 639} 640 641/* lock oriented handlers */ 642/* TODO: handlers for CPU oriented, thread oriented */ 643static 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, 648}; 649 650static struct trace_lock_handler *trace_handler; 651 652static int perf_evsel__process_lock_acquire(struct perf_evsel *evsel, 653 struct perf_sample *sample) 654{ 655 if (trace_handler->acquire_event) 656 return trace_handler->acquire_event(evsel, sample); 657 return 0; 658} 659 660static int perf_evsel__process_lock_acquired(struct perf_evsel *evsel, 661 struct perf_sample *sample) 662{ 663 if (trace_handler->acquired_event) 664 return trace_handler->acquired_event(evsel, sample); 665 return 0; 666} 667 668static int perf_evsel__process_lock_contended(struct perf_evsel *evsel, 669 struct perf_sample *sample) 670{ 671 if (trace_handler->contended_event) 672 return trace_handler->contended_event(evsel, sample); 673 return 0; 674} 675 676static int perf_evsel__process_lock_release(struct perf_evsel *evsel, 677 struct perf_sample *sample) 678{ 679 if (trace_handler->release_event) 680 return trace_handler->release_event(evsel, sample); 681 return 0; 682} 683 684static 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"); 692 pr_info("bad: %d, total: %d\n", bad, total); 693 pr_info("bad rate: %f %%\n", (double)bad / (double)total * 100); 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 699/* TODO: various way to print, coloring, nano or milli sec */ 700static void print_result(void) 701{ 702 struct lock_stat *st; 703 char cut_name[20]; 704 int bad, total; 705 706 pr_info("%20s ", "Name"); 707 pr_info("%10s ", "acquired"); 708 pr_info("%10s ", "contended"); 709 710 pr_info("%15s ", "total wait (ns)"); 711 pr_info("%15s ", "max wait (ns)"); 712 pr_info("%15s ", "min wait (ns)"); 713 714 pr_info("\n\n"); 715 716 bad = total = 0; 717 while ((st = pop_from_result())) { 718 total++; 719 if (st->discard) { 720 bad++; 721 continue; 722 } 723 bzero(cut_name, 20); 724 725 if (strlen(st->name) < 16) { 726 /* output raw name */ 727 pr_info("%20s ", st->name); 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 */ 735 pr_info("%20s ", cut_name); 736 } 737 738 pr_info("%10u ", st->nr_acquired); 739 pr_info("%10u ", st->nr_contended); 740 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 ? 744 0 : st->wait_time_min); 745 pr_info("\n"); 746 } 747 748 print_bad_events(bad, total); 749} 750 751static bool info_threads, info_map; 752 753static 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 770static void dump_map(void) 771{ 772 unsigned int i; 773 struct lock_stat *st; 774 775 pr_info("Address of instance: name of class\n"); 776 for (i = 0; i < LOCKHASH_SIZE; i++) { 777 list_for_each_entry(st, &lockhash_table[i], hash_entry) { 778 pr_info(" %p: %s\n", st->addr, st->name); 779 } 780 } 781} 782 783static int dump_info(void) 784{ 785 int rc = 0; 786 787 if (info_threads) 788 dump_threads(); 789 else if (info_map) 790 dump_map(); 791 else { 792 rc = -1; 793 pr_err("Unknown type of information\n"); 794 } 795 796 return rc; 797} 798 799typedef int (*tracepoint_handler)(struct perf_evsel *evsel, 800 struct perf_sample *sample); 801 802static int process_sample_event(struct perf_tool *tool __maybe_unused, 803 union perf_event *event, 804 struct perf_sample *sample, 805 struct perf_evsel *evsel, 806 struct machine *machine) 807{ 808 struct thread *thread = machine__findnew_thread(machine, sample->pid, 809 sample->tid); 810 811 if (thread == NULL) { 812 pr_debug("problem processing %d event, skipping it.\n", 813 event->header.type); 814 return -1; 815 } 816 817 if (evsel->handler.func != NULL) { 818 tracepoint_handler f = evsel->handler.func; 819 return f(evsel, sample); 820 } 821 822 return 0; 823} 824 825static const struct perf_evsel_str_handler lock_tracepoints[] = { 826 { "lock:lock_acquire", perf_evsel__process_lock_acquire, }, /* CONFIG_LOCKDEP */ 827 { "lock:lock_acquired", perf_evsel__process_lock_acquired, }, /* CONFIG_LOCKDEP, CONFIG_LOCK_STAT */ 828 { "lock:lock_contended", perf_evsel__process_lock_contended, }, /* CONFIG_LOCKDEP, CONFIG_LOCK_STAT */ 829 { "lock:lock_release", perf_evsel__process_lock_release, }, /* CONFIG_LOCKDEP */ 830}; 831 832static int read_events(void) 833{ 834 struct perf_tool eops = { 835 .sample = process_sample_event, 836 .comm = perf_event__process_comm, 837 .ordered_samples = true, 838 }; 839 session = perf_session__new(input_name, O_RDONLY, 0, false, &eops); 840 if (!session) { 841 pr_err("Initializing perf session failed\n"); 842 return -1; 843 } 844 845 if (perf_session__set_tracepoints_handlers(session, lock_tracepoints)) { 846 pr_err("Initializing perf session tracepoint handlers failed\n"); 847 return -1; 848 } 849 850 return perf_session__process_events(session, &eops); 851} 852 853static void sort_result(void) 854{ 855 unsigned int i; 856 struct lock_stat *st; 857 858 for (i = 0; i < LOCKHASH_SIZE; i++) { 859 list_for_each_entry(st, &lockhash_table[i], hash_entry) { 860 insert_to_result(st, compare); 861 } 862 } 863} 864 865static int __cmd_report(void) 866{ 867 setup_pager(); 868 869 if ((select_key() != 0) || 870 (read_events() != 0)) 871 return -1; 872 873 sort_result(); 874 print_result(); 875 876 return 0; 877} 878 879static int __cmd_record(int argc, const char **argv) 880{ 881 const char *record_args[] = { 882 "record", "-R", "-m", "1024", "-c", "1", 883 }; 884 unsigned int rec_argc, i, j; 885 const char **rec_argv; 886 887 for (i = 0; i < ARRAY_SIZE(lock_tracepoints); i++) { 888 if (!is_valid_tracepoint(lock_tracepoints[i].name)) { 889 pr_err("tracepoint %s is not enabled. " 890 "Are CONFIG_LOCKDEP and CONFIG_LOCK_STAT enabled?\n", 891 lock_tracepoints[i].name); 892 return 1; 893 } 894 } 895 896 rec_argc = ARRAY_SIZE(record_args) + argc - 1; 897 /* factor of 2 is for -e in front of each tracepoint */ 898 rec_argc += 2 * ARRAY_SIZE(lock_tracepoints); 899 900 rec_argv = calloc(rec_argc + 1, sizeof(char *)); 901 if (rec_argv == NULL) 902 return -ENOMEM; 903 904 for (i = 0; i < ARRAY_SIZE(record_args); i++) 905 rec_argv[i] = strdup(record_args[i]); 906 907 for (j = 0; j < ARRAY_SIZE(lock_tracepoints); j++) { 908 rec_argv[i++] = "-e"; 909 rec_argv[i++] = strdup(lock_tracepoints[j].name); 910 } 911 912 for (j = 1; j < (unsigned int)argc; j++, i++) 913 rec_argv[i] = argv[j]; 914 915 BUG_ON(i != rec_argc); 916 917 return cmd_record(i, rec_argv, NULL); 918} 919 920int cmd_lock(int argc, const char **argv, const char *prefix __maybe_unused) 921{ 922 const struct option info_options[] = { 923 OPT_BOOLEAN('t', "threads", &info_threads, 924 "dump thread list in perf.data"), 925 OPT_BOOLEAN('m', "map", &info_map, 926 "map of lock instances (address:name table)"), 927 OPT_END() 928 }; 929 const struct option lock_options[] = { 930 OPT_STRING('i', "input", &input_name, "file", "input file name"), 931 OPT_INCR('v', "verbose", &verbose, "be more verbose (show symbol address, etc)"), 932 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, "dump raw trace in ASCII"), 933 OPT_END() 934 }; 935 const struct option report_options[] = { 936 OPT_STRING('k', "key", &sort_key, "acquired", 937 "key for sorting (acquired / contended / wait_total / wait_max / wait_min)"), 938 /* TODO: type */ 939 OPT_END() 940 }; 941 const char * const info_usage[] = { 942 "perf lock info [<options>]", 943 NULL 944 }; 945 const char * const lock_usage[] = { 946 "perf lock [<options>] {record|report|script|info}", 947 NULL 948 }; 949 const char * const report_usage[] = { 950 "perf lock report [<options>]", 951 NULL 952 }; 953 unsigned int i; 954 int rc = 0; 955 956 symbol__init(); 957 for (i = 0; i < LOCKHASH_SIZE; i++) 958 INIT_LIST_HEAD(lockhash_table + i); 959 960 argc = parse_options(argc, argv, lock_options, lock_usage, 961 PARSE_OPT_STOP_AT_NON_OPTION); 962 if (!argc) 963 usage_with_options(lock_usage, lock_options); 964 965 if (!strncmp(argv[0], "rec", 3)) { 966 return __cmd_record(argc, argv); 967 } else if (!strncmp(argv[0], "report", 6)) { 968 trace_handler = &report_lock_ops; 969 if (argc) { 970 argc = parse_options(argc, argv, 971 report_options, report_usage, 0); 972 if (argc) 973 usage_with_options(report_usage, report_options); 974 } 975 __cmd_report(); 976 } else if (!strcmp(argv[0], "script")) { 977 /* Aliased to 'perf script' */ 978 return cmd_script(argc, argv, prefix); 979 } else if (!strcmp(argv[0], "info")) { 980 if (argc) { 981 argc = parse_options(argc, argv, 982 info_options, info_usage, 0); 983 if (argc) 984 usage_with_options(info_usage, info_options); 985 } 986 /* recycling report_lock_ops */ 987 trace_handler = &report_lock_ops; 988 setup_pager(); 989 if (read_events() != 0) 990 rc = -1; 991 else 992 rc = dump_info(); 993 } else { 994 usage_with_options(lock_usage, lock_options); 995 } 996 997 return rc; 998} 999