tools/perf/builtin-lock.c

   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                 free(new);
 326                 goto alloc_failed;
 327         }
 328
 329         strcpy(new->name, name);
 330         new->wait_time_min = ULLONG_MAX;
 331
 332         list_add(&new->hash_entry, entry);
 333         return new;
 334
 335 alloc_failed:
 336         pr_err("memory allocation failed\n");
 337         return NULL;
 338 }
 339
 340 struct trace_lock_handler {
 341         int (*acquire_event)(struct perf_evsel *evsel,
 342                              struct perf_sample *sample);
 343
 344         int (*acquired_event)(struct perf_evsel *evsel,
 345                               struct perf_sample *sample);
 346
 347         int (*contended_event)(struct perf_evsel *evsel,
 348                                struct perf_sample *sample);
 349
 350         int (*release_event)(struct perf_evsel *evsel,
 351                              struct perf_sample *sample);
 352 };
 353
 354 static struct lock_seq_stat *get_seq(struct thread_stat *ts, void *addr)
 355 {
 356         struct lock_seq_stat *seq;
 357
 358         list_for_each_entry(seq, &ts->seq_list, list) {
 359                 if (seq->addr == addr)
 360                         return seq;
 361         }
 362
 363         seq = zalloc(sizeof(struct lock_seq_stat));
 364         if (!seq) {
 365                 pr_err("memory allocation failed\n");
 366                 return NULL;
 367         }
 368         seq->state = SEQ_STATE_UNINITIALIZED;
 369         seq->addr = addr;
 370
 371         list_add(&seq->list, &ts->seq_list);
 372         return seq;
 373 }
 374
 375 enum broken_state {
 376         BROKEN_ACQUIRE,
 377         BROKEN_ACQUIRED,
 378         BROKEN_CONTENDED,
 379         BROKEN_RELEASE,
 380         BROKEN_MAX,
 381 };
 382
 383 static int bad_hist[BROKEN_MAX];
 384
 385 enum acquire_flags {
 386         TRY_LOCK = 1,
 387         READ_LOCK = 2,
 388 };
 389
 390 static int report_lock_acquire_event(struct perf_evsel *evsel,
 391                                      struct perf_sample *sample)
 392 {
 393         void *addr;
 394         struct lock_stat *ls;
 395         struct thread_stat *ts;
 396         struct lock_seq_stat *seq;
 397         const char *name = perf_evsel__strval(evsel, sample, "name");
 398         u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr");
 399         int flag = perf_evsel__intval(evsel, sample, "flag");
 400
 401         memcpy(&addr, &tmp, sizeof(void *));
 402
 403         ls = lock_stat_findnew(addr, name);
 404         if (!ls)
 405                 return -ENOMEM;
 406         if (ls->discard)
 407                 return 0;
 408
 409         ts = thread_stat_findnew(sample->tid);
 410         if (!ts)
 411                 return -ENOMEM;
 412
 413         seq = get_seq(ts, addr);
 414         if (!seq)
 415                 return -ENOMEM;
 416
 417         switch (seq->state) {
 418         case SEQ_STATE_UNINITIALIZED:
 419         case SEQ_STATE_RELEASED:
 420                 if (!flag) {
 421                         seq->state = SEQ_STATE_ACQUIRING;
 422                 } else {
 423                         if (flag & TRY_LOCK)
 424                                 ls->nr_trylock++;
 425                         if (flag & READ_LOCK)
 426                                 ls->nr_readlock++;
 427                         seq->state = SEQ_STATE_READ_ACQUIRED;
 428                         seq->read_count = 1;
 429                         ls->nr_acquired++;
 430                 }
 431                 break;
 432         case SEQ_STATE_READ_ACQUIRED:
 433                 if (flag & READ_LOCK) {
 434                         seq->read_count++;
 435                         ls->nr_acquired++;
 436                         goto end;
 437                 } else {
 438                         goto broken;
 439                 }
 440                 break;
 441         case SEQ_STATE_ACQUIRED:
 442         case SEQ_STATE_ACQUIRING:
 443         case SEQ_STATE_CONTENDED:
 444 broken:
 445                 /* broken lock sequence, discard it */
 446                 ls->discard = 1;
 447                 bad_hist[BROKEN_ACQUIRE]++;
 448                 list_del(&seq->list);
 449                 free(seq);
 450                 goto end;
 451         default:
 452                 BUG_ON("Unknown state of lock sequence found!\n");
 453                 break;
 454         }
 455
 456         ls->nr_acquire++;
 457         seq->prev_event_time = sample->time;
 458 end:
 459         return 0;
 460 }
 461
 462 static int report_lock_acquired_event(struct perf_evsel *evsel,
 463                                       struct perf_sample *sample)
 464 {
 465         void *addr;
 466         struct lock_stat *ls;
 467         struct thread_stat *ts;
 468         struct lock_seq_stat *seq;
 469         u64 contended_term;
 470         const char *name = perf_evsel__strval(evsel, sample, "name");
 471         u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr");
 472
 473         memcpy(&addr, &tmp, sizeof(void *));
 474
 475         ls = lock_stat_findnew(addr, name);
 476         if (!ls)
 477                 return -ENOMEM;
 478         if (ls->discard)
 479                 return 0;
 480
 481         ts = thread_stat_findnew(sample->tid);
 482         if (!ts)
 483                 return -ENOMEM;
 484
 485         seq = get_seq(ts, addr);
 486         if (!seq)
 487                 return -ENOMEM;
 488
 489         switch (seq->state) {
 490         case SEQ_STATE_UNINITIALIZED:
 491                 /* orphan event, do nothing */
 492                 return 0;
 493         case SEQ_STATE_ACQUIRING:
 494                 break;
 495         case SEQ_STATE_CONTENDED:
 496                 contended_term = sample->time - seq->prev_event_time;
 497                 ls->wait_time_total += contended_term;
 498                 if (contended_term < ls->wait_time_min)
 499                         ls->wait_time_min = contended_term;
 500                 if (ls->wait_time_max < contended_term)
 501                         ls->wait_time_max = contended_term;
 502                 break;
 503         case SEQ_STATE_RELEASED:
 504         case SEQ_STATE_ACQUIRED:
 505         case SEQ_STATE_READ_ACQUIRED:
 506                 /* broken lock sequence, discard it */
 507                 ls->discard = 1;
 508                 bad_hist[BROKEN_ACQUIRED]++;
 509                 list_del(&seq->list);
 510                 free(seq);
 511                 goto end;
 512         default:
 513                 BUG_ON("Unknown state of lock sequence found!\n");
 514                 break;
 515         }
 516
 517         seq->state = SEQ_STATE_ACQUIRED;
 518         ls->nr_acquired++;
 519         seq->prev_event_time = sample->time;
 520 end:
 521         return 0;
 522 }
 523
 524 static int report_lock_contended_event(struct perf_evsel *evsel,
 525                                        struct perf_sample *sample)
 526 {
 527         void *addr;
 528         struct lock_stat *ls;
 529         struct thread_stat *ts;
 530         struct lock_seq_stat *seq;
 531         const char *name = perf_evsel__strval(evsel, sample, "name");
 532         u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr");
 533
 534         memcpy(&addr, &tmp, sizeof(void *));
 535
 536         ls = lock_stat_findnew(addr, name);
 537         if (!ls)
 538                 return -ENOMEM;
 539         if (ls->discard)
 540                 return 0;
 541
 542         ts = thread_stat_findnew(sample->tid);
 543         if (!ts)
 544                 return -ENOMEM;
 545
 546         seq = get_seq(ts, addr);
 547         if (!seq)
 548                 return -ENOMEM;
 549
 550         switch (seq->state) {
 551         case SEQ_STATE_UNINITIALIZED:
 552                 /* orphan event, do nothing */
 553                 return 0;
 554         case SEQ_STATE_ACQUIRING:
 555                 break;
 556         case SEQ_STATE_RELEASED:
 557         case SEQ_STATE_ACQUIRED:
 558         case SEQ_STATE_READ_ACQUIRED:
 559         case SEQ_STATE_CONTENDED:
 560                 /* broken lock sequence, discard it */
 561                 ls->discard = 1;
 562                 bad_hist[BROKEN_CONTENDED]++;
 563                 list_del(&seq->list);
 564                 free(seq);
 565                 goto end;
 566         default:
 567                 BUG_ON("Unknown state of lock sequence found!\n");
 568                 break;
 569         }
 570
 571         seq->state = SEQ_STATE_CONTENDED;
 572         ls->nr_contended++;
 573         seq->prev_event_time = sample->time;
 574 end:
 575         return 0;
 576 }
 577
 578 static int report_lock_release_event(struct perf_evsel *evsel,
 579                                      struct perf_sample *sample)
 580 {
 581         void *addr;
 582         struct lock_stat *ls;
 583         struct thread_stat *ts;
 584         struct lock_seq_stat *seq;
 585         const char *name = perf_evsel__strval(evsel, sample, "name");
 586         u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr");
 587
 588         memcpy(&addr, &tmp, sizeof(void *));
 589
 590         ls = lock_stat_findnew(addr, name);
 591         if (!ls)
 592                 return -ENOMEM;
 593         if (ls->discard)
 594                 return 0;
 595
 596         ts = thread_stat_findnew(sample->tid);
 597         if (!ts)
 598                 return -ENOMEM;
 599
 600         seq = get_seq(ts, addr);
 601         if (!seq)
 602                 return -ENOMEM;
 603
 604         switch (seq->state) {
 605         case SEQ_STATE_UNINITIALIZED:
 606                 goto end;
 607         case SEQ_STATE_ACQUIRED:
 608                 break;
 609         case SEQ_STATE_READ_ACQUIRED:
 610                 seq->read_count--;
 611                 BUG_ON(seq->read_count < 0);
 612                 if (!seq->read_count) {
 613                         ls->nr_release++;
 614                         goto end;
 615                 }
 616                 break;
 617         case SEQ_STATE_ACQUIRING:
 618         case SEQ_STATE_CONTENDED:
 619         case SEQ_STATE_RELEASED:
 620                 /* broken lock sequence, discard it */
 621                 ls->discard = 1;
 622                 bad_hist[BROKEN_RELEASE]++;
 623                 goto free_seq;
 624         default:
 625                 BUG_ON("Unknown state of lock sequence found!\n");
 626                 break;
 627         }
 628
 629         ls->nr_release++;
 630 free_seq:
 631         list_del(&seq->list);
 632         free(seq);
 633 end:
 634         return 0;
 635 }
 636
 637 /* lock oriented handlers */
 638 /* TODO: handlers for CPU oriented, thread oriented */
 639 static struct trace_lock_handler report_lock_ops  = {
 640         .acquire_event          = report_lock_acquire_event,
 641         .acquired_event         = report_lock_acquired_event,
 642         .contended_event        = report_lock_contended_event,
 643         .release_event          = report_lock_release_event,
 644 };
 645
 646 static struct trace_lock_handler *trace_handler;
 647
 648 static int perf_evsel__process_lock_acquire(struct perf_evsel *evsel,
 649                                              struct perf_sample *sample)
 650 {
 651         if (trace_handler->acquire_event)
 652                 return trace_handler->acquire_event(evsel, sample);
 653         return 0;
 654 }
 655
 656 static int perf_evsel__process_lock_acquired(struct perf_evsel *evsel,
 657                                               struct perf_sample *sample)
 658 {
 659         if (trace_handler->acquired_event)
 660                 return trace_handler->acquired_event(evsel, sample);
 661         return 0;
 662 }
 663
 664 static int perf_evsel__process_lock_contended(struct perf_evsel *evsel,
 665                                               struct perf_sample *sample)
 666 {
 667         if (trace_handler->contended_event)
 668                 return trace_handler->contended_event(evsel, sample);
 669         return 0;
 670 }
 671
 672 static int perf_evsel__process_lock_release(struct perf_evsel *evsel,
 673                                             struct perf_sample *sample)
 674 {
 675         if (trace_handler->release_event)
 676                 return trace_handler->release_event(evsel, sample);
 677         return 0;
 678 }
 679
 680 static void print_bad_events(int bad, int total)
 681 {
 682         /* Output for debug, this have to be removed */
 683         int i;
 684         const char *name[4] =
 685                 { "acquire", "acquired", "contended", "release" };
 686
 687         pr_info("\n=== output for debug===\n\n");
 688         pr_info("bad: %d, total: %d\n", bad, total);
 689         pr_info("bad rate: %.2f %%\n", (double)bad / (double)total * 100);
 690         pr_info("histogram of events caused bad sequence\n");
 691         for (i = 0; i < BROKEN_MAX; i++)
 692                 pr_info(" %10s: %d\n", name[i], bad_hist[i]);
 693 }
 694
 695 /* TODO: various way to print, coloring, nano or milli sec */
 696 static void print_result(void)
 697 {
 698         struct lock_stat *st;
 699         char cut_name[20];
 700         int bad, total;
 701
 702         pr_info("%20s ", "Name");
 703         pr_info("%10s ", "acquired");
 704         pr_info("%10s ", "contended");
 705
 706         pr_info("%15s ", "total wait (ns)");
 707         pr_info("%15s ", "max wait (ns)");
 708         pr_info("%15s ", "min wait (ns)");
 709
 710         pr_info("\n\n");
 711
 712         bad = total = 0;
 713         while ((st = pop_from_result())) {
 714                 total++;
 715                 if (st->discard) {
 716                         bad++;
 717                         continue;
 718                 }
 719                 bzero(cut_name, 20);
 720
 721                 if (strlen(st->name) < 16) {
 722                         /* output raw name */
 723                         pr_info("%20s ", st->name);
 724                 } else {
 725                         strncpy(cut_name, st->name, 16);
 726                         cut_name[16] = '.';
 727                         cut_name[17] = '.';
 728                         cut_name[18] = '.';
 729                         cut_name[19] = '\0';
 730                         /* cut off name for saving output style */
 731                         pr_info("%20s ", cut_name);
 732                 }
 733
 734                 pr_info("%10u ", st->nr_acquired);
 735                 pr_info("%10u ", st->nr_contended);
 736
 737                 pr_info("%15" PRIu64 " ", st->wait_time_total);
 738                 pr_info("%15" PRIu64 " ", st->wait_time_max);
 739                 pr_info("%15" PRIu64 " ", st->wait_time_min == ULLONG_MAX ?
 740                        0 : st->wait_time_min);
 741                 pr_info("\n");
 742         }
 743
 744         print_bad_events(bad, total);
 745 }
 746
 747 static bool info_threads, info_map;
 748
 749 static void dump_threads(void)
 750 {
 751         struct thread_stat *st;
 752         struct rb_node *node;
 753         struct thread *t;
 754
 755         pr_info("%10s: comm\n", "Thread ID");
 756
 757         node = rb_first(&thread_stats);
 758         while (node) {
 759                 st = container_of(node, struct thread_stat, rb);
 760                 t = perf_session__findnew(session, st->tid);
 761                 pr_info("%10d: %s\n", st->tid, t->comm);
 762                 node = rb_next(node);
 763         };
 764 }
 765
 766 static void dump_map(void)
 767 {
 768         unsigned int i;
 769         struct lock_stat *st;
 770
 771         pr_info("Address of instance: name of class\n");
 772         for (i = 0; i < LOCKHASH_SIZE; i++) {
 773                 list_for_each_entry(st, &lockhash_table[i], hash_entry) {
 774                         pr_info(" %p: %s\n", st->addr, st->name);
 775                 }
 776         }
 777 }
 778
 779 static int dump_info(void)
 780 {
 781         int rc = 0;
 782
 783         if (info_threads)
 784                 dump_threads();
 785         else if (info_map)
 786                 dump_map();
 787         else {
 788                 rc = -1;
 789                 pr_err("Unknown type of information\n");
 790         }
 791
 792         return rc;
 793 }
 794
 795 typedef int (*tracepoint_handler)(struct perf_evsel *evsel,
 796                                   struct perf_sample *sample);
 797
 798 static int process_sample_event(struct perf_tool *tool __maybe_unused,
 799                                 union perf_event *event,
 800                                 struct perf_sample *sample,
 801                                 struct perf_evsel *evsel,
 802                                 struct machine *machine)
 803 {
 804         struct thread *thread = machine__findnew_thread(machine, sample->pid,
 805                                                         sample->tid);
 806
 807         if (thread == NULL) {
 808                 pr_debug("problem processing %d event, skipping it.\n",
 809                         event->header.type);
 810                 return -1;
 811         }
 812
 813         if (evsel->handler.func != NULL) {
 814                 tracepoint_handler f = evsel->handler.func;
 815                 return f(evsel, sample);
 816         }
 817
 818         return 0;
 819 }
 820
 821 static void sort_result(void)
 822 {
 823         unsigned int i;
 824         struct lock_stat *st;
 825
 826         for (i = 0; i < LOCKHASH_SIZE; i++) {
 827                 list_for_each_entry(st, &lockhash_table[i], hash_entry) {
 828                         insert_to_result(st, compare);
 829                 }
 830         }
 831 }
 832
 833 static const struct perf_evsel_str_handler lock_tracepoints[] = {
 834         { "lock:lock_acquire",   perf_evsel__process_lock_acquire,   }, /* CONFIG_LOCKDEP */
 835         { "lock:lock_acquired",  perf_evsel__process_lock_acquired,  }, /* CONFIG_LOCKDEP, CONFIG_LOCK_STAT */
 836         { "lock:lock_contended", perf_evsel__process_lock_contended, }, /* CONFIG_LOCKDEP, CONFIG_LOCK_STAT */
 837         { "lock:lock_release",   perf_evsel__process_lock_release,   }, /* CONFIG_LOCKDEP */
 838 };
 839
 840 static int __cmd_report(bool display_info)
 841 {
 842         int err = -EINVAL;
 843         struct perf_tool eops = {
 844                 .sample          = process_sample_event,
 845                 .comm            = perf_event__process_comm,
 846                 .ordered_samples = true,
 847         };
 848
 849         session = perf_session__new(input_name, O_RDONLY, 0, false, &eops);
 850         if (!session) {
 851                 pr_err("Initializing perf session failed\n");
 852                 return -ENOMEM;
 853         }
 854
 855         if (!perf_session__has_traces(session, "lock record"))
 856                 goto out_delete;
 857
 858         if (perf_session__set_tracepoints_handlers(session, lock_tracepoints)) {
 859                 pr_err("Initializing perf session tracepoint handlers failed\n");
 860                 goto out_delete;
 861         }
 862
 863         if (select_key())
 864                 goto out_delete;
 865
 866         err = perf_session__process_events(session, &eops);
 867         if (err)
 868                 goto out_delete;
 869
 870         setup_pager();
 871         if (display_info) /* used for info subcommand */
 872                 err = dump_info();
 873         else {
 874                 sort_result();
 875                 print_result();
 876         }
 877
 878 out_delete:
 879         perf_session__delete(session);
 880         return err;
 881 }
 882
 883 static int __cmd_record(int argc, const char **argv)
 884 {
 885         const char *record_args[] = {
 886                 "record", "-R", "-m", "1024", "-c", "1",
 887         };
 888         unsigned int rec_argc, i, j, ret;
 889         const char **rec_argv;
 890
 891         for (i = 0; i < ARRAY_SIZE(lock_tracepoints); i++) {
 892                 if (!is_valid_tracepoint(lock_tracepoints[i].name)) {
 893                                 pr_err("tracepoint %s is not enabled. "
 894                                        "Are CONFIG_LOCKDEP and CONFIG_LOCK_STAT enabled?\n",
 895                                        lock_tracepoints[i].name);
 896                                 return 1;
 897                 }
 898         }
 899
 900         rec_argc = ARRAY_SIZE(record_args) + argc - 1;
 901         /* factor of 2 is for -e in front of each tracepoint */
 902         rec_argc += 2 * ARRAY_SIZE(lock_tracepoints);
 903
 904         rec_argv = calloc(rec_argc + 1, sizeof(char *));
 905         if (!rec_argv)
 906                 return -ENOMEM;
 907
 908         for (i = 0; i < ARRAY_SIZE(record_args); i++)
 909                 rec_argv[i] = strdup(record_args[i]);
 910
 911         for (j = 0; j < ARRAY_SIZE(lock_tracepoints); j++) {
 912                 rec_argv[i++] = "-e";
 913                 rec_argv[i++] = strdup(lock_tracepoints[j].name);
 914         }
 915
 916         for (j = 1; j < (unsigned int)argc; j++, i++)
 917                 rec_argv[i] = argv[j];
 918
 919         BUG_ON(i != rec_argc);
 920
 921         ret = cmd_record(i, rec_argv, NULL);
 922         free(rec_argv);
 923         return ret;
 924 }
 925
 926 int cmd_lock(int argc, const char **argv, const char *prefix __maybe_unused)
 927 {
 928         const struct option info_options[] = {
 929         OPT_BOOLEAN('t', "threads", &info_threads,
 930                     "dump thread list in perf.data"),
 931         OPT_BOOLEAN('m', "map", &info_map,
 932                     "map of lock instances (address:name table)"),
 933         OPT_END()
 934         };
 935         const struct option lock_options[] = {
 936         OPT_STRING('i', "input", &input_name, "file", "input file name"),
 937         OPT_INCR('v', "verbose", &verbose, "be more verbose (show symbol address, etc)"),
 938         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, "dump raw trace in ASCII"),
 939         OPT_END()
 940         };
 941         const struct option report_options[] = {
 942         OPT_STRING('k', "key", &sort_key, "acquired",
 943                     "key for sorting (acquired / contended / wait_total / wait_max / wait_min)"),
 944         /* TODO: type */
 945         OPT_END()
 946         };
 947         const char * const info_usage[] = {
 948                 "perf lock info [<options>]",
 949                 NULL
 950         };
 951         const char * const lock_usage[] = {
 952                 "perf lock [<options>] {record|report|script|info}",
 953                 NULL
 954         };
 955         const char * const report_usage[] = {
 956                 "perf lock report [<options>]",
 957                 NULL
 958         };
 959         unsigned int i;
 960         int rc = 0;
 961
 962         symbol__init();
 963         for (i = 0; i < LOCKHASH_SIZE; i++)
 964                 INIT_LIST_HEAD(lockhash_table + i);
 965
 966         argc = parse_options(argc, argv, lock_options, lock_usage,
 967                              PARSE_OPT_STOP_AT_NON_OPTION);
 968         if (!argc)
 969                 usage_with_options(lock_usage, lock_options);
 970
 971         if (!strncmp(argv[0], "rec", 3)) {
 972                 return __cmd_record(argc, argv);
 973         } else if (!strncmp(argv[0], "report", 6)) {
 974                 trace_handler = &report_lock_ops;
 975                 if (argc) {
 976                         argc = parse_options(argc, argv,
 977                                              report_options, report_usage, 0);
 978                         if (argc)
 979                                 usage_with_options(report_usage, report_options);
 980                 }
 981                 rc = __cmd_report(false);
 982         } else if (!strcmp(argv[0], "script")) {
 983                 /* Aliased to 'perf script' */
 984                 return cmd_script(argc, argv, prefix);
 985         } else if (!strcmp(argv[0], "info")) {
 986                 if (argc) {
 987                         argc = parse_options(argc, argv,
 988                                              info_options, info_usage, 0);
 989                         if (argc)
 990                                 usage_with_options(info_usage, info_options);
 991                 }
 992                 /* recycling report_lock_ops */
 993                 trace_handler = &report_lock_ops;
 994                 rc = __cmd_report(true);
 995         } else {
 996                 usage_with_options(lock_usage, lock_options);
 997         }
 998
 999         return rc;
1000 }