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 29 static struct perf_session *session; 30 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 40 struct 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 */ 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; 104 }; 105 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)); 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 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)); 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 209 SINGLE_KEY(nr_acquired) 210 SINGLE_KEY(nr_contended) 211 SINGLE_KEY(wait_time_total) 212 SINGLE_KEY(wait_time_max) 213 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 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 */ 232 const char *name; 233 int (*key)(struct lock_stat*, struct lock_stat*); 234 }; 235 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 */ 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 256 static 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 272 static 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 */ 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 308 static 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 333 alloc_failed: 334 pr_err("memory allocation failed\n"); 335 return NULL; 336 } 337 338 struct 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 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)); 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 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]; 382 383 enum acquire_flags { 384 TRY_LOCK = 1, 385 READ_LOCK = 2, 386 }; 387 388 static 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: 442 broken: 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; 457 end: 458 return 0; 459 } 460 461 static 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; 521 end: 522 return 0; 523 } 524 525 static 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; 576 end: 577 return 0; 578 } 579 580 static 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++; 634 free_seq: 635 list_del(&seq->list); 636 free(seq); 637 end: 638 return 0; 639 } 640 641 /* lock oriented handlers */ 642 /* TODO: handlers for CPU oriented, thread oriented */ 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, 648 }; 649 650 static struct trace_lock_handler *trace_handler; 651 652 static 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 660 static 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 668 static 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 676 static 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 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"); 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 */ 700 static 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 751 static bool info_threads, info_map; 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 770 static 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 783 static 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 799 typedef int (*tracepoint_handler)(struct perf_evsel *evsel, 800 struct perf_sample *sample); 801 802 static 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->tid); 809 810 if (thread == NULL) { 811 pr_debug("problem processing %d event, skipping it.\n", 812 event->header.type); 813 return -1; 814 } 815 816 if (evsel->handler.func != NULL) { 817 tracepoint_handler f = evsel->handler.func; 818 return f(evsel, sample); 819 } 820 821 return 0; 822 } 823 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 831 static int read_events(void) 832 { 833 struct perf_tool eops = { 834 .sample = process_sample_event, 835 .comm = perf_event__process_comm, 836 .ordered_samples = true, 837 }; 838 session = perf_session__new(input_name, O_RDONLY, 0, false, &eops); 839 if (!session) { 840 pr_err("Initializing perf session failed\n"); 841 return -1; 842 } 843 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 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 864 static int __cmd_report(void) 865 { 866 setup_pager(); 867 868 if ((select_key() != 0) || 869 (read_events() != 0)) 870 return -1; 871 872 sort_result(); 873 print_result(); 874 875 return 0; 876 } 877 878 static int __cmd_record(int argc, const char **argv) 879 { 880 const char *record_args[] = { 881 "record", "-R", "-f", "-m", "1024", "-c", "1", 882 }; 883 unsigned int rec_argc, i, j; 884 const char **rec_argv; 885 886 for (i = 0; i < ARRAY_SIZE(lock_tracepoints); i++) { 887 if (!is_valid_tracepoint(lock_tracepoints[i].name)) { 888 pr_err("tracepoint %s is not enabled. " 889 "Are CONFIG_LOCKDEP and CONFIG_LOCK_STAT enabled?\n", 890 lock_tracepoints[i].name); 891 return 1; 892 } 893 } 894 895 rec_argc = ARRAY_SIZE(record_args) + argc - 1; 896 /* factor of 2 is for -e in front of each tracepoint */ 897 rec_argc += 2 * ARRAY_SIZE(lock_tracepoints); 898 899 rec_argv = calloc(rec_argc + 1, sizeof(char *)); 900 if (rec_argv == NULL) 901 return -ENOMEM; 902 903 for (i = 0; i < ARRAY_SIZE(record_args); i++) 904 rec_argv[i] = strdup(record_args[i]); 905 906 for (j = 0; j < ARRAY_SIZE(lock_tracepoints); j++) { 907 rec_argv[i++] = "-e"; 908 rec_argv[i++] = strdup(lock_tracepoints[j].name); 909 } 910 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 919 int cmd_lock(int argc, const char **argv, const char *prefix __maybe_unused) 920 { 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 }; 952 unsigned int i; 953 int rc = 0; 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); 966 } else if (!strncmp(argv[0], "report", 6)) { 967 trace_handler = &report_lock_ops; 968 if (argc) { 969 argc = parse_options(argc, argv, 970 report_options, report_usage, 0); 971 if (argc) 972 usage_with_options(report_usage, report_options); 973 } 974 __cmd_report(); 975 } else if (!strcmp(argv[0], "script")) { 976 /* Aliased to 'perf script' */ 977 return cmd_script(argc, argv, prefix); 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 } 985 /* recycling report_lock_ops */ 986 trace_handler = &report_lock_ops; 987 setup_pager(); 988 if (read_events() != 0) 989 rc = -1; 990 else 991 rc = dump_info(); 992 } else { 993 usage_with_options(lock_usage, lock_options); 994 } 995 996 return rc; 997 } 998