5 #include "util/cache.h"
6 #include "util/symbol.h"
7 #include "util/thread.h"
8 #include "util/header.h"
10 #include "util/parse-options.h"
11 #include "util/trace-event.h"
13 #include "util/debug.h"
14 #include "util/session.h"
16 #include <sys/types.h>
17 #include <sys/prctl.h>
18 #include <semaphore.h>
23 #include <linux/list.h>
24 #include <linux/hash.h>
26 static struct perf_session
*session
;
28 /* based on kernel/lockdep.c */
29 #define LOCKHASH_BITS 12
30 #define LOCKHASH_SIZE (1UL << LOCKHASH_BITS)
32 static struct list_head lockhash_table
[LOCKHASH_SIZE
];
34 #define __lockhashfn(key) hash_long((unsigned long)key, LOCKHASH_BITS)
35 #define lockhashentry(key) (lockhash_table + __lockhashfn((key)))
38 struct list_head hash_entry
;
39 struct rb_node rb
; /* used for sorting */
42 * FIXME: raw_field_value() returns unsigned long long,
43 * so address of lockdep_map should be dealed as 64bit.
44 * Is there more better solution?
46 void *addr
; /* address of lockdep_map, used as ID */
47 char *name
; /* for strcpy(), we cannot use const */
49 unsigned int nr_acquire
;
50 unsigned int nr_acquired
;
51 unsigned int nr_contended
;
52 unsigned int nr_release
;
54 unsigned int nr_readlock
;
55 unsigned int nr_trylock
;
56 /* these times are in nano sec. */
61 int discard
; /* flag of blacklist */
65 * States of lock_seq_stat
67 * UNINITIALIZED is required for detecting first event of acquire.
68 * As the nature of lock events, there is no guarantee
69 * that the first event for the locks are acquire,
70 * it can be acquired, contended or release.
72 #define SEQ_STATE_UNINITIALIZED 0 /* initial state */
73 #define SEQ_STATE_RELEASED 1
74 #define SEQ_STATE_ACQUIRING 2
75 #define SEQ_STATE_ACQUIRED 3
76 #define SEQ_STATE_READ_ACQUIRED 4
77 #define SEQ_STATE_CONTENDED 5
81 * Imported from include/linux/sched.h.
82 * Should this be synchronized?
84 #define MAX_LOCK_DEPTH 48
87 * struct lock_seq_stat:
88 * Place to put on state of one lock sequence
89 * 1) acquire -> acquired -> release
90 * 2) acquire -> contended -> acquired -> release
91 * 3) acquire (with read or try) -> release
92 * 4) Are there other patterns?
94 struct lock_seq_stat
{
95 struct list_head list
;
107 struct list_head seq_list
;
110 static struct rb_root thread_stats
;
112 static struct thread_stat
*thread_stat_find(u32 tid
)
114 struct rb_node
*node
;
115 struct thread_stat
*st
;
117 node
= thread_stats
.rb_node
;
119 st
= container_of(node
, struct thread_stat
, rb
);
122 else if (tid
< st
->tid
)
123 node
= node
->rb_left
;
125 node
= node
->rb_right
;
131 static void thread_stat_insert(struct thread_stat
*new)
133 struct rb_node
**rb
= &thread_stats
.rb_node
;
134 struct rb_node
*parent
= NULL
;
135 struct thread_stat
*p
;
138 p
= container_of(*rb
, struct thread_stat
, rb
);
141 if (new->tid
< p
->tid
)
142 rb
= &(*rb
)->rb_left
;
143 else if (new->tid
> p
->tid
)
144 rb
= &(*rb
)->rb_right
;
146 BUG_ON("inserting invalid thread_stat\n");
149 rb_link_node(&new->rb
, parent
, rb
);
150 rb_insert_color(&new->rb
, &thread_stats
);
153 static struct thread_stat
*thread_stat_findnew_after_first(u32 tid
)
155 struct thread_stat
*st
;
157 st
= thread_stat_find(tid
);
161 st
= zalloc(sizeof(struct thread_stat
));
163 die("memory allocation failed\n");
166 INIT_LIST_HEAD(&st
->seq_list
);
168 thread_stat_insert(st
);
173 static struct thread_stat
*thread_stat_findnew_first(u32 tid
);
174 static struct thread_stat
*(*thread_stat_findnew
)(u32 tid
) =
175 thread_stat_findnew_first
;
177 static struct thread_stat
*thread_stat_findnew_first(u32 tid
)
179 struct thread_stat
*st
;
181 st
= zalloc(sizeof(struct thread_stat
));
183 die("memory allocation failed\n");
185 INIT_LIST_HEAD(&st
->seq_list
);
187 rb_link_node(&st
->rb
, NULL
, &thread_stats
.rb_node
);
188 rb_insert_color(&st
->rb
, &thread_stats
);
190 thread_stat_findnew
= thread_stat_findnew_after_first
;
194 /* build simple key function one is bigger than two */
195 #define SINGLE_KEY(member) \
196 static int lock_stat_key_ ## member(struct lock_stat *one, \
197 struct lock_stat *two) \
199 return one->member > two->member; \
202 SINGLE_KEY(nr_acquired
)
203 SINGLE_KEY(nr_contended
)
204 SINGLE_KEY(wait_time_total
)
205 SINGLE_KEY(wait_time_max
)
207 static int lock_stat_key_wait_time_min(struct lock_stat
*one
,
208 struct lock_stat
*two
)
210 u64 s1
= one
->wait_time_min
;
211 u64 s2
= two
->wait_time_min
;
212 if (s1
== ULLONG_MAX
)
214 if (s2
== ULLONG_MAX
)
221 * name: the value for specify by user
222 * this should be simpler than raw name of member
223 * e.g. nr_acquired -> acquired, wait_time_total -> wait_total
226 int (*key
)(struct lock_stat
*, struct lock_stat
*);
229 static const char *sort_key
= "acquired";
231 static int (*compare
)(struct lock_stat
*, struct lock_stat
*);
233 static struct rb_root result
; /* place to store sorted data */
235 #define DEF_KEY_LOCK(name, fn_suffix) \
236 { #name, lock_stat_key_ ## fn_suffix }
237 struct lock_key keys
[] = {
238 DEF_KEY_LOCK(acquired
, nr_acquired
),
239 DEF_KEY_LOCK(contended
, nr_contended
),
240 DEF_KEY_LOCK(wait_total
, wait_time_total
),
241 DEF_KEY_LOCK(wait_min
, wait_time_min
),
242 DEF_KEY_LOCK(wait_max
, wait_time_max
),
244 /* extra comparisons much complicated should be here */
249 static void select_key(void)
253 for (i
= 0; keys
[i
].name
; i
++) {
254 if (!strcmp(keys
[i
].name
, sort_key
)) {
255 compare
= keys
[i
].key
;
260 die("Unknown compare key:%s\n", sort_key
);
263 static void insert_to_result(struct lock_stat
*st
,
264 int (*bigger
)(struct lock_stat
*, struct lock_stat
*))
266 struct rb_node
**rb
= &result
.rb_node
;
267 struct rb_node
*parent
= NULL
;
271 p
= container_of(*rb
, struct lock_stat
, rb
);
275 rb
= &(*rb
)->rb_left
;
277 rb
= &(*rb
)->rb_right
;
280 rb_link_node(&st
->rb
, parent
, rb
);
281 rb_insert_color(&st
->rb
, &result
);
284 /* returns left most element of result, and erase it */
285 static struct lock_stat
*pop_from_result(void)
287 struct rb_node
*node
= result
.rb_node
;
292 while (node
->rb_left
)
293 node
= node
->rb_left
;
295 rb_erase(node
, &result
);
296 return container_of(node
, struct lock_stat
, rb
);
299 static struct lock_stat
*lock_stat_findnew(void *addr
, const char *name
)
301 struct list_head
*entry
= lockhashentry(addr
);
302 struct lock_stat
*ret
, *new;
304 list_for_each_entry(ret
, entry
, hash_entry
) {
305 if (ret
->addr
== addr
)
309 new = zalloc(sizeof(struct lock_stat
));
314 new->name
= zalloc(sizeof(char) * strlen(name
) + 1);
317 strcpy(new->name
, name
);
319 new->wait_time_min
= ULLONG_MAX
;
321 list_add(&new->hash_entry
, entry
);
325 die("memory allocation failed\n");
328 static char const *input_name
= "perf.data";
330 struct raw_event_sample
{
335 struct trace_acquire_event
{
341 struct trace_acquired_event
{
346 struct trace_contended_event
{
351 struct trace_release_event
{
356 struct trace_lock_handler
{
357 void (*acquire_event
)(struct trace_acquire_event
*,
361 struct thread
*thread
);
363 void (*acquired_event
)(struct trace_acquired_event
*,
367 struct thread
*thread
);
369 void (*contended_event
)(struct trace_contended_event
*,
373 struct thread
*thread
);
375 void (*release_event
)(struct trace_release_event
*,
379 struct thread
*thread
);
382 static struct lock_seq_stat
*get_seq(struct thread_stat
*ts
, void *addr
)
384 struct lock_seq_stat
*seq
;
386 list_for_each_entry(seq
, &ts
->seq_list
, list
) {
387 if (seq
->addr
== addr
)
391 seq
= zalloc(sizeof(struct lock_seq_stat
));
393 die("Not enough memory\n");
394 seq
->state
= SEQ_STATE_UNINITIALIZED
;
397 list_add(&seq
->list
, &ts
->seq_list
);
409 static int bad_hist
[BROKEN_MAX
];
417 report_lock_acquire_event(struct trace_acquire_event
*acquire_event
,
418 struct event
*__event __used
,
420 u64 timestamp __used
,
421 struct thread
*thread __used
)
423 struct lock_stat
*ls
;
424 struct thread_stat
*ts
;
425 struct lock_seq_stat
*seq
;
427 ls
= lock_stat_findnew(acquire_event
->addr
, acquire_event
->name
);
431 ts
= thread_stat_findnew(thread
->pid
);
432 seq
= get_seq(ts
, acquire_event
->addr
);
434 switch (seq
->state
) {
435 case SEQ_STATE_UNINITIALIZED
:
436 case SEQ_STATE_RELEASED
:
437 if (!acquire_event
->flag
) {
438 seq
->state
= SEQ_STATE_ACQUIRING
;
440 if (acquire_event
->flag
& TRY_LOCK
)
442 if (acquire_event
->flag
& READ_LOCK
)
444 seq
->state
= SEQ_STATE_READ_ACQUIRED
;
449 case SEQ_STATE_READ_ACQUIRED
:
450 if (acquire_event
->flag
& READ_LOCK
) {
458 case SEQ_STATE_ACQUIRED
:
459 case SEQ_STATE_ACQUIRING
:
460 case SEQ_STATE_CONTENDED
:
462 /* broken lock sequence, discard it */
464 bad_hist
[BROKEN_ACQUIRE
]++;
465 list_del(&seq
->list
);
470 BUG_ON("Unknown state of lock sequence found!\n");
475 seq
->prev_event_time
= timestamp
;
481 report_lock_acquired_event(struct trace_acquired_event
*acquired_event
,
482 struct event
*__event __used
,
484 u64 timestamp __used
,
485 struct thread
*thread __used
)
487 struct lock_stat
*ls
;
488 struct thread_stat
*ts
;
489 struct lock_seq_stat
*seq
;
492 ls
= lock_stat_findnew(acquired_event
->addr
, acquired_event
->name
);
496 ts
= thread_stat_findnew(thread
->pid
);
497 seq
= get_seq(ts
, acquired_event
->addr
);
499 switch (seq
->state
) {
500 case SEQ_STATE_UNINITIALIZED
:
501 /* orphan event, do nothing */
503 case SEQ_STATE_ACQUIRING
:
505 case SEQ_STATE_CONTENDED
:
506 contended_term
= timestamp
- seq
->prev_event_time
;
507 ls
->wait_time_total
+= contended_term
;
508 if (contended_term
< ls
->wait_time_min
)
509 ls
->wait_time_min
= contended_term
;
510 if (ls
->wait_time_max
< contended_term
)
511 ls
->wait_time_max
= contended_term
;
513 case SEQ_STATE_RELEASED
:
514 case SEQ_STATE_ACQUIRED
:
515 case SEQ_STATE_READ_ACQUIRED
:
516 /* broken lock sequence, discard it */
518 bad_hist
[BROKEN_ACQUIRED
]++;
519 list_del(&seq
->list
);
525 BUG_ON("Unknown state of lock sequence found!\n");
529 seq
->state
= SEQ_STATE_ACQUIRED
;
531 seq
->prev_event_time
= timestamp
;
537 report_lock_contended_event(struct trace_contended_event
*contended_event
,
538 struct event
*__event __used
,
540 u64 timestamp __used
,
541 struct thread
*thread __used
)
543 struct lock_stat
*ls
;
544 struct thread_stat
*ts
;
545 struct lock_seq_stat
*seq
;
547 ls
= lock_stat_findnew(contended_event
->addr
, contended_event
->name
);
551 ts
= thread_stat_findnew(thread
->pid
);
552 seq
= get_seq(ts
, contended_event
->addr
);
554 switch (seq
->state
) {
555 case SEQ_STATE_UNINITIALIZED
:
556 /* orphan event, do nothing */
558 case SEQ_STATE_ACQUIRING
:
560 case SEQ_STATE_RELEASED
:
561 case SEQ_STATE_ACQUIRED
:
562 case SEQ_STATE_READ_ACQUIRED
:
563 case SEQ_STATE_CONTENDED
:
564 /* broken lock sequence, discard it */
566 bad_hist
[BROKEN_CONTENDED
]++;
567 list_del(&seq
->list
);
572 BUG_ON("Unknown state of lock sequence found!\n");
576 seq
->state
= SEQ_STATE_CONTENDED
;
578 seq
->prev_event_time
= timestamp
;
584 report_lock_release_event(struct trace_release_event
*release_event
,
585 struct event
*__event __used
,
587 u64 timestamp __used
,
588 struct thread
*thread __used
)
590 struct lock_stat
*ls
;
591 struct thread_stat
*ts
;
592 struct lock_seq_stat
*seq
;
594 ls
= lock_stat_findnew(release_event
->addr
, release_event
->name
);
598 ts
= thread_stat_findnew(thread
->pid
);
599 seq
= get_seq(ts
, release_event
->addr
);
601 switch (seq
->state
) {
602 case SEQ_STATE_UNINITIALIZED
:
605 case SEQ_STATE_ACQUIRED
:
607 case SEQ_STATE_READ_ACQUIRED
:
609 BUG_ON(seq
->read_count
< 0);
610 if (!seq
->read_count
) {
615 case SEQ_STATE_ACQUIRING
:
616 case SEQ_STATE_CONTENDED
:
617 case SEQ_STATE_RELEASED
:
618 /* broken lock sequence, discard it */
620 bad_hist
[BROKEN_RELEASE
]++;
624 BUG_ON("Unknown state of lock sequence found!\n");
630 list_del(&seq
->list
);
636 /* lock oriented handlers */
637 /* TODO: handlers for CPU oriented, thread oriented */
638 static struct trace_lock_handler report_lock_ops
= {
639 .acquire_event
= report_lock_acquire_event
,
640 .acquired_event
= report_lock_acquired_event
,
641 .contended_event
= report_lock_contended_event
,
642 .release_event
= report_lock_release_event
,
645 static struct trace_lock_handler
*trace_handler
;
648 process_lock_acquire_event(void *data
,
649 struct event
*event __used
,
651 u64 timestamp __used
,
652 struct thread
*thread __used
)
654 struct trace_acquire_event acquire_event
;
655 u64 tmp
; /* this is required for casting... */
657 tmp
= raw_field_value(event
, "lockdep_addr", data
);
658 memcpy(&acquire_event
.addr
, &tmp
, sizeof(void *));
659 acquire_event
.name
= (char *)raw_field_ptr(event
, "name", data
);
660 acquire_event
.flag
= (int)raw_field_value(event
, "flag", data
);
662 if (trace_handler
->acquire_event
)
663 trace_handler
->acquire_event(&acquire_event
, event
, cpu
, timestamp
, thread
);
667 process_lock_acquired_event(void *data
,
668 struct event
*event __used
,
670 u64 timestamp __used
,
671 struct thread
*thread __used
)
673 struct trace_acquired_event acquired_event
;
674 u64 tmp
; /* this is required for casting... */
676 tmp
= raw_field_value(event
, "lockdep_addr", data
);
677 memcpy(&acquired_event
.addr
, &tmp
, sizeof(void *));
678 acquired_event
.name
= (char *)raw_field_ptr(event
, "name", data
);
680 if (trace_handler
->acquire_event
)
681 trace_handler
->acquired_event(&acquired_event
, event
, cpu
, timestamp
, thread
);
685 process_lock_contended_event(void *data
,
686 struct event
*event __used
,
688 u64 timestamp __used
,
689 struct thread
*thread __used
)
691 struct trace_contended_event contended_event
;
692 u64 tmp
; /* this is required for casting... */
694 tmp
= raw_field_value(event
, "lockdep_addr", data
);
695 memcpy(&contended_event
.addr
, &tmp
, sizeof(void *));
696 contended_event
.name
= (char *)raw_field_ptr(event
, "name", data
);
698 if (trace_handler
->acquire_event
)
699 trace_handler
->contended_event(&contended_event
, event
, cpu
, timestamp
, thread
);
703 process_lock_release_event(void *data
,
704 struct event
*event __used
,
706 u64 timestamp __used
,
707 struct thread
*thread __used
)
709 struct trace_release_event release_event
;
710 u64 tmp
; /* this is required for casting... */
712 tmp
= raw_field_value(event
, "lockdep_addr", data
);
713 memcpy(&release_event
.addr
, &tmp
, sizeof(void *));
714 release_event
.name
= (char *)raw_field_ptr(event
, "name", data
);
716 if (trace_handler
->acquire_event
)
717 trace_handler
->release_event(&release_event
, event
, cpu
, timestamp
, thread
);
721 process_raw_event(void *data
, int cpu
, u64 timestamp
, struct thread
*thread
)
726 type
= trace_parse_common_type(data
);
727 event
= trace_find_event(type
);
729 if (!strcmp(event
->name
, "lock_acquire"))
730 process_lock_acquire_event(data
, event
, cpu
, timestamp
, thread
);
731 if (!strcmp(event
->name
, "lock_acquired"))
732 process_lock_acquired_event(data
, event
, cpu
, timestamp
, thread
);
733 if (!strcmp(event
->name
, "lock_contended"))
734 process_lock_contended_event(data
, event
, cpu
, timestamp
, thread
);
735 if (!strcmp(event
->name
, "lock_release"))
736 process_lock_release_event(data
, event
, cpu
, timestamp
, thread
);
739 static void print_bad_events(int bad
, int total
)
741 /* Output for debug, this have to be removed */
743 const char *name
[4] =
744 { "acquire", "acquired", "contended", "release" };
746 pr_info("\n=== output for debug===\n\n");
747 pr_info("bad: %d, total: %d\n", bad
, total
);
748 pr_info("bad rate: %f %%\n", (double)bad
/ (double)total
* 100);
749 pr_info("histogram of events caused bad sequence\n");
750 for (i
= 0; i
< BROKEN_MAX
; i
++)
751 pr_info(" %10s: %d\n", name
[i
], bad_hist
[i
]);
754 /* TODO: various way to print, coloring, nano or milli sec */
755 static void print_result(void)
757 struct lock_stat
*st
;
761 pr_info("%20s ", "Name");
762 pr_info("%10s ", "acquired");
763 pr_info("%10s ", "contended");
765 pr_info("%15s ", "total wait (ns)");
766 pr_info("%15s ", "max wait (ns)");
767 pr_info("%15s ", "min wait (ns)");
772 while ((st
= pop_from_result())) {
780 if (strlen(st
->name
) < 16) {
781 /* output raw name */
782 pr_info("%20s ", st
->name
);
784 strncpy(cut_name
, st
->name
, 16);
789 /* cut off name for saving output style */
790 pr_info("%20s ", cut_name
);
793 pr_info("%10u ", st
->nr_acquired
);
794 pr_info("%10u ", st
->nr_contended
);
796 pr_info("%15" PRIu64
" ", st
->wait_time_total
);
797 pr_info("%15" PRIu64
" ", st
->wait_time_max
);
798 pr_info("%15" PRIu64
" ", st
->wait_time_min
== ULLONG_MAX
?
799 0 : st
->wait_time_min
);
803 print_bad_events(bad
, total
);
806 static bool info_threads
, info_map
;
808 static void dump_threads(void)
810 struct thread_stat
*st
;
811 struct rb_node
*node
;
814 pr_info("%10s: comm\n", "Thread ID");
816 node
= rb_first(&thread_stats
);
818 st
= container_of(node
, struct thread_stat
, rb
);
819 t
= perf_session__findnew(session
, st
->tid
);
820 pr_info("%10d: %s\n", st
->tid
, t
->comm
);
821 node
= rb_next(node
);
825 static void dump_map(void)
828 struct lock_stat
*st
;
830 pr_info("Address of instance: name of class\n");
831 for (i
= 0; i
< LOCKHASH_SIZE
; i
++) {
832 list_for_each_entry(st
, &lockhash_table
[i
], hash_entry
) {
833 pr_info(" %p: %s\n", st
->addr
, st
->name
);
838 static void dump_info(void)
845 die("Unknown type of information\n");
848 static int process_sample_event(union perf_event
*event
,
849 struct perf_sample
*sample
,
850 struct perf_evsel
*evsel __used
,
851 struct perf_session
*s
)
853 struct thread
*thread
= perf_session__findnew(s
, sample
->tid
);
855 if (thread
== NULL
) {
856 pr_debug("problem processing %d event, skipping it.\n",
861 process_raw_event(sample
->raw_data
, sample
->cpu
, sample
->time
, thread
);
866 static struct perf_event_ops eops
= {
867 .sample
= process_sample_event
,
868 .comm
= perf_event__process_comm
,
869 .ordered_samples
= true,
872 static int read_events(void)
874 session
= perf_session__new(input_name
, O_RDONLY
, 0, false, &eops
);
876 die("Initializing perf session failed\n");
878 return perf_session__process_events(session
, &eops
);
881 static void sort_result(void)
884 struct lock_stat
*st
;
886 for (i
= 0; i
< LOCKHASH_SIZE
; i
++) {
887 list_for_each_entry(st
, &lockhash_table
[i
], hash_entry
) {
888 insert_to_result(st
, compare
);
893 static void __cmd_report(void)
902 static const char * const report_usage
[] = {
903 "perf lock report [<options>]",
907 static const struct option report_options
[] = {
908 OPT_STRING('k', "key", &sort_key
, "acquired",
909 "key for sorting (acquired / contended / wait_total / wait_max / wait_min)"),
914 static const char * const info_usage
[] = {
915 "perf lock info [<options>]",
919 static const struct option info_options
[] = {
920 OPT_BOOLEAN('t', "threads", &info_threads
,
921 "dump thread list in perf.data"),
922 OPT_BOOLEAN('m', "map", &info_map
,
923 "map of lock instances (name:address table)"),
927 static const char * const lock_usage
[] = {
928 "perf lock [<options>] {record|trace|report}",
932 static const struct option lock_options
[] = {
933 OPT_STRING('i', "input", &input_name
, "file", "input file name"),
934 OPT_INCR('v', "verbose", &verbose
, "be more verbose (show symbol address, etc)"),
935 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace
, "dump raw trace in ASCII"),
939 static const char *record_args
[] = {
945 "-e", "lock:lock_acquire",
946 "-e", "lock:lock_acquired",
947 "-e", "lock:lock_contended",
948 "-e", "lock:lock_release",
951 static int __cmd_record(int argc
, const char **argv
)
953 unsigned int rec_argc
, i
, j
;
954 const char **rec_argv
;
956 rec_argc
= ARRAY_SIZE(record_args
) + argc
- 1;
957 rec_argv
= calloc(rec_argc
+ 1, sizeof(char *));
959 if (rec_argv
== NULL
)
962 for (i
= 0; i
< ARRAY_SIZE(record_args
); i
++)
963 rec_argv
[i
] = strdup(record_args
[i
]);
965 for (j
= 1; j
< (unsigned int)argc
; j
++, i
++)
966 rec_argv
[i
] = argv
[j
];
968 BUG_ON(i
!= rec_argc
);
970 return cmd_record(i
, rec_argv
, NULL
);
973 int cmd_lock(int argc
, const char **argv
, const char *prefix __used
)
978 for (i
= 0; i
< LOCKHASH_SIZE
; i
++)
979 INIT_LIST_HEAD(lockhash_table
+ i
);
981 argc
= parse_options(argc
, argv
, lock_options
, lock_usage
,
982 PARSE_OPT_STOP_AT_NON_OPTION
);
984 usage_with_options(lock_usage
, lock_options
);
986 if (!strncmp(argv
[0], "rec", 3)) {
987 return __cmd_record(argc
, argv
);
988 } else if (!strncmp(argv
[0], "report", 6)) {
989 trace_handler
= &report_lock_ops
;
991 argc
= parse_options(argc
, argv
,
992 report_options
, report_usage
, 0);
994 usage_with_options(report_usage
, report_options
);
997 } else if (!strcmp(argv
[0], "script")) {
998 /* Aliased to 'perf script' */
999 return cmd_script(argc
, argv
, prefix
);
1000 } else if (!strcmp(argv
[0], "info")) {
1002 argc
= parse_options(argc
, argv
,
1003 info_options
, info_usage
, 0);
1005 usage_with_options(info_usage
, info_options
);
1007 /* recycling report_lock_ops */
1008 trace_handler
= &report_lock_ops
;
1013 usage_with_options(lock_usage
, lock_options
);