4 #include "util/evlist.h"
5 #include "util/evsel.h"
7 #include "util/cache.h"
8 #include "util/symbol.h"
9 #include "util/thread.h"
10 #include "util/header.h"
12 #include "util/parse-options.h"
13 #include "util/trace-event.h"
15 #include "util/debug.h"
16 #include "util/session.h"
17 #include "util/tool.h"
19 #include <sys/types.h>
20 #include <sys/prctl.h>
21 #include <semaphore.h>
26 #include <linux/list.h>
27 #include <linux/hash.h>
29 static struct perf_session
*session
;
31 /* based on kernel/lockdep.c */
32 #define LOCKHASH_BITS 12
33 #define LOCKHASH_SIZE (1UL << LOCKHASH_BITS)
35 static struct list_head lockhash_table
[LOCKHASH_SIZE
];
37 #define __lockhashfn(key) hash_long((unsigned long)key, LOCKHASH_BITS)
38 #define lockhashentry(key) (lockhash_table + __lockhashfn((key)))
41 struct list_head hash_entry
;
42 struct rb_node rb
; /* used for sorting */
45 * FIXME: perf_evsel__intval() returns u64,
46 * so address of lockdep_map should be dealed as 64bit.
47 * Is there more better solution?
49 void *addr
; /* address of lockdep_map, used as ID */
50 char *name
; /* for strcpy(), we cannot use const */
52 unsigned int nr_acquire
;
53 unsigned int nr_acquired
;
54 unsigned int nr_contended
;
55 unsigned int nr_release
;
57 unsigned int nr_readlock
;
58 unsigned int nr_trylock
;
59 /* these times are in nano sec. */
64 int discard
; /* flag of blacklist */
68 * States of lock_seq_stat
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.
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
84 * Imported from include/linux/sched.h.
85 * Should this be synchronized?
87 #define MAX_LOCK_DEPTH 48
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?
97 struct lock_seq_stat
{
98 struct list_head list
;
110 struct list_head seq_list
;
113 static struct rb_root thread_stats
;
115 static struct thread_stat
*thread_stat_find(u32 tid
)
117 struct rb_node
*node
;
118 struct thread_stat
*st
;
120 node
= thread_stats
.rb_node
;
122 st
= container_of(node
, struct thread_stat
, rb
);
125 else if (tid
< st
->tid
)
126 node
= node
->rb_left
;
128 node
= node
->rb_right
;
134 static void thread_stat_insert(struct thread_stat
*new)
136 struct rb_node
**rb
= &thread_stats
.rb_node
;
137 struct rb_node
*parent
= NULL
;
138 struct thread_stat
*p
;
141 p
= container_of(*rb
, struct thread_stat
, rb
);
144 if (new->tid
< p
->tid
)
145 rb
= &(*rb
)->rb_left
;
146 else if (new->tid
> p
->tid
)
147 rb
= &(*rb
)->rb_right
;
149 BUG_ON("inserting invalid thread_stat\n");
152 rb_link_node(&new->rb
, parent
, rb
);
153 rb_insert_color(&new->rb
, &thread_stats
);
156 static struct thread_stat
*thread_stat_findnew_after_first(u32 tid
)
158 struct thread_stat
*st
;
160 st
= thread_stat_find(tid
);
164 st
= zalloc(sizeof(struct thread_stat
));
166 pr_err("memory allocation failed\n");
171 INIT_LIST_HEAD(&st
->seq_list
);
173 thread_stat_insert(st
);
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
;
182 static struct thread_stat
*thread_stat_findnew_first(u32 tid
)
184 struct thread_stat
*st
;
186 st
= zalloc(sizeof(struct thread_stat
));
188 pr_err("memory allocation failed\n");
192 INIT_LIST_HEAD(&st
->seq_list
);
194 rb_link_node(&st
->rb
, NULL
, &thread_stats
.rb_node
);
195 rb_insert_color(&st
->rb
, &thread_stats
);
197 thread_stat_findnew
= thread_stat_findnew_after_first
;
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) \
206 return one->member > two->member; \
209 SINGLE_KEY(nr_acquired
)
210 SINGLE_KEY(nr_contended
)
211 SINGLE_KEY(wait_time_total
)
212 SINGLE_KEY(wait_time_max
)
214 static int lock_stat_key_wait_time_min(struct lock_stat
*one
,
215 struct lock_stat
*two
)
217 u64 s1
= one
->wait_time_min
;
218 u64 s2
= two
->wait_time_min
;
219 if (s1
== ULLONG_MAX
)
221 if (s2
== ULLONG_MAX
)
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
233 int (*key
)(struct lock_stat
*, struct lock_stat
*);
236 static const char *sort_key
= "acquired";
238 static int (*compare
)(struct lock_stat
*, struct lock_stat
*);
240 static struct rb_root result
; /* place to store sorted data */
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
),
251 /* extra comparisons much complicated should be here */
256 static int select_key(void)
260 for (i
= 0; keys
[i
].name
; i
++) {
261 if (!strcmp(keys
[i
].name
, sort_key
)) {
262 compare
= keys
[i
].key
;
267 pr_err("Unknown compare key: %s\n", sort_key
);
272 static void insert_to_result(struct lock_stat
*st
,
273 int (*bigger
)(struct lock_stat
*, struct lock_stat
*))
275 struct rb_node
**rb
= &result
.rb_node
;
276 struct rb_node
*parent
= NULL
;
280 p
= container_of(*rb
, struct lock_stat
, rb
);
284 rb
= &(*rb
)->rb_left
;
286 rb
= &(*rb
)->rb_right
;
289 rb_link_node(&st
->rb
, parent
, rb
);
290 rb_insert_color(&st
->rb
, &result
);
293 /* returns left most element of result, and erase it */
294 static struct lock_stat
*pop_from_result(void)
296 struct rb_node
*node
= result
.rb_node
;
301 while (node
->rb_left
)
302 node
= node
->rb_left
;
304 rb_erase(node
, &result
);
305 return container_of(node
, struct lock_stat
, rb
);
308 static struct lock_stat
*lock_stat_findnew(void *addr
, const char *name
)
310 struct list_head
*entry
= lockhashentry(addr
);
311 struct lock_stat
*ret
, *new;
313 list_for_each_entry(ret
, entry
, hash_entry
) {
314 if (ret
->addr
== addr
)
318 new = zalloc(sizeof(struct lock_stat
));
323 new->name
= zalloc(sizeof(char) * strlen(name
) + 1);
326 strcpy(new->name
, name
);
328 new->wait_time_min
= ULLONG_MAX
;
330 list_add(&new->hash_entry
, entry
);
334 pr_err("memory allocation failed\n");
338 struct trace_lock_handler
{
339 int (*acquire_event
)(struct perf_evsel
*evsel
,
340 struct perf_sample
*sample
);
342 int (*acquired_event
)(struct perf_evsel
*evsel
,
343 struct perf_sample
*sample
);
345 int (*contended_event
)(struct perf_evsel
*evsel
,
346 struct perf_sample
*sample
);
348 int (*release_event
)(struct perf_evsel
*evsel
,
349 struct perf_sample
*sample
);
352 static struct lock_seq_stat
*get_seq(struct thread_stat
*ts
, void *addr
)
354 struct lock_seq_stat
*seq
;
356 list_for_each_entry(seq
, &ts
->seq_list
, list
) {
357 if (seq
->addr
== addr
)
361 seq
= zalloc(sizeof(struct lock_seq_stat
));
363 pr_err("memory allocation failed\n");
366 seq
->state
= SEQ_STATE_UNINITIALIZED
;
369 list_add(&seq
->list
, &ts
->seq_list
);
381 static int bad_hist
[BROKEN_MAX
];
388 static int report_lock_acquire_event(struct perf_evsel
*evsel
,
389 struct perf_sample
*sample
)
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");
399 memcpy(&addr
, &tmp
, sizeof(void *));
401 ls
= lock_stat_findnew(addr
, name
);
407 ts
= thread_stat_findnew(sample
->tid
);
411 seq
= get_seq(ts
, addr
);
415 switch (seq
->state
) {
416 case SEQ_STATE_UNINITIALIZED
:
417 case SEQ_STATE_RELEASED
:
419 seq
->state
= SEQ_STATE_ACQUIRING
;
423 if (flag
& READ_LOCK
)
425 seq
->state
= SEQ_STATE_READ_ACQUIRED
;
430 case SEQ_STATE_READ_ACQUIRED
:
431 if (flag
& READ_LOCK
) {
439 case SEQ_STATE_ACQUIRED
:
440 case SEQ_STATE_ACQUIRING
:
441 case SEQ_STATE_CONTENDED
:
443 /* broken lock sequence, discard it */
445 bad_hist
[BROKEN_ACQUIRE
]++;
446 list_del(&seq
->list
);
451 BUG_ON("Unknown state of lock sequence found!\n");
456 seq
->prev_event_time
= sample
->time
;
461 static int report_lock_acquired_event(struct perf_evsel
*evsel
,
462 struct perf_sample
*sample
)
465 struct lock_stat
*ls
;
466 struct thread_stat
*ts
;
467 struct lock_seq_stat
*seq
;
469 const char *name
= perf_evsel__strval(evsel
, sample
, "name");
470 u64 tmp
= perf_evsel__intval(evsel
, sample
, "lockdep_addr");
472 memcpy(&addr
, &tmp
, sizeof(void *));
474 ls
= lock_stat_findnew(addr
, name
);
480 ts
= thread_stat_findnew(sample
->tid
);
484 seq
= get_seq(ts
, addr
);
488 switch (seq
->state
) {
489 case SEQ_STATE_UNINITIALIZED
:
490 /* orphan event, do nothing */
492 case SEQ_STATE_ACQUIRING
:
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
;
502 case SEQ_STATE_RELEASED
:
503 case SEQ_STATE_ACQUIRED
:
504 case SEQ_STATE_READ_ACQUIRED
:
505 /* broken lock sequence, discard it */
507 bad_hist
[BROKEN_ACQUIRED
]++;
508 list_del(&seq
->list
);
514 BUG_ON("Unknown state of lock sequence found!\n");
518 seq
->state
= SEQ_STATE_ACQUIRED
;
520 seq
->prev_event_time
= sample
->time
;
525 static int report_lock_contended_event(struct perf_evsel
*evsel
,
526 struct perf_sample
*sample
)
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");
535 memcpy(&addr
, &tmp
, sizeof(void *));
537 ls
= lock_stat_findnew(addr
, name
);
543 ts
= thread_stat_findnew(sample
->tid
);
547 seq
= get_seq(ts
, addr
);
551 switch (seq
->state
) {
552 case SEQ_STATE_UNINITIALIZED
:
553 /* orphan event, do nothing */
555 case SEQ_STATE_ACQUIRING
:
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 */
563 bad_hist
[BROKEN_CONTENDED
]++;
564 list_del(&seq
->list
);
569 BUG_ON("Unknown state of lock sequence found!\n");
573 seq
->state
= SEQ_STATE_CONTENDED
;
575 seq
->prev_event_time
= sample
->time
;
580 static int report_lock_release_event(struct perf_evsel
*evsel
,
581 struct perf_sample
*sample
)
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");
590 memcpy(&addr
, &tmp
, sizeof(void *));
592 ls
= lock_stat_findnew(addr
, name
);
598 ts
= thread_stat_findnew(sample
->tid
);
602 seq
= get_seq(ts
, addr
);
606 switch (seq
->state
) {
607 case SEQ_STATE_UNINITIALIZED
:
610 case SEQ_STATE_ACQUIRED
:
612 case SEQ_STATE_READ_ACQUIRED
:
614 BUG_ON(seq
->read_count
< 0);
615 if (!seq
->read_count
) {
620 case SEQ_STATE_ACQUIRING
:
621 case SEQ_STATE_CONTENDED
:
622 case SEQ_STATE_RELEASED
:
623 /* broken lock sequence, discard it */
625 bad_hist
[BROKEN_RELEASE
]++;
629 BUG_ON("Unknown state of lock sequence found!\n");
635 list_del(&seq
->list
);
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
,
650 static struct trace_lock_handler
*trace_handler
;
652 static int perf_evsel__process_lock_acquire(struct perf_evsel
*evsel
,
653 struct perf_sample
*sample
)
655 if (trace_handler
->acquire_event
)
656 return trace_handler
->acquire_event(evsel
, sample
);
660 static int perf_evsel__process_lock_acquired(struct perf_evsel
*evsel
,
661 struct perf_sample
*sample
)
663 if (trace_handler
->acquired_event
)
664 return trace_handler
->acquired_event(evsel
, sample
);
668 static int perf_evsel__process_lock_contended(struct perf_evsel
*evsel
,
669 struct perf_sample
*sample
)
671 if (trace_handler
->contended_event
)
672 return trace_handler
->contended_event(evsel
, sample
);
676 static int perf_evsel__process_lock_release(struct perf_evsel
*evsel
,
677 struct perf_sample
*sample
)
679 if (trace_handler
->release_event
)
680 return trace_handler
->release_event(evsel
, sample
);
684 static void print_bad_events(int bad
, int total
)
686 /* Output for debug, this have to be removed */
688 const char *name
[4] =
689 { "acquire", "acquired", "contended", "release" };
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
]);
699 /* TODO: various way to print, coloring, nano or milli sec */
700 static void print_result(void)
702 struct lock_stat
*st
;
706 pr_info("%20s ", "Name");
707 pr_info("%10s ", "acquired");
708 pr_info("%10s ", "contended");
710 pr_info("%15s ", "total wait (ns)");
711 pr_info("%15s ", "max wait (ns)");
712 pr_info("%15s ", "min wait (ns)");
717 while ((st
= pop_from_result())) {
725 if (strlen(st
->name
) < 16) {
726 /* output raw name */
727 pr_info("%20s ", st
->name
);
729 strncpy(cut_name
, st
->name
, 16);
734 /* cut off name for saving output style */
735 pr_info("%20s ", cut_name
);
738 pr_info("%10u ", st
->nr_acquired
);
739 pr_info("%10u ", st
->nr_contended
);
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
);
748 print_bad_events(bad
, total
);
751 static bool info_threads
, info_map
;
753 static void dump_threads(void)
755 struct thread_stat
*st
;
756 struct rb_node
*node
;
759 pr_info("%10s: comm\n", "Thread ID");
761 node
= rb_first(&thread_stats
);
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
);
770 static void dump_map(void)
773 struct lock_stat
*st
;
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
);
783 static int dump_info(void)
793 pr_err("Unknown type of information\n");
799 typedef int (*tracepoint_handler
)(struct perf_evsel
*evsel
,
800 struct perf_sample
*sample
);
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
)
808 struct thread
*thread
= machine__findnew_thread(machine
, sample
->pid
,
811 if (thread
== NULL
) {
812 pr_debug("problem processing %d event, skipping it.\n",
817 if (evsel
->handler
.func
!= NULL
) {
818 tracepoint_handler f
= evsel
->handler
.func
;
819 return f(evsel
, sample
);
825 static 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 */
832 static int read_events(void)
834 struct perf_tool eops
= {
835 .sample
= process_sample_event
,
836 .comm
= perf_event__process_comm
,
837 .ordered_samples
= true,
839 session
= perf_session__new(input_name
, O_RDONLY
, 0, false, &eops
);
841 pr_err("Initializing perf session failed\n");
845 if (perf_session__set_tracepoints_handlers(session
, lock_tracepoints
)) {
846 pr_err("Initializing perf session tracepoint handlers failed\n");
850 return perf_session__process_events(session
, &eops
);
853 static void sort_result(void)
856 struct lock_stat
*st
;
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
);
865 static int __cmd_report(void)
869 if ((select_key() != 0) ||
870 (read_events() != 0))
879 static int __cmd_record(int argc
, const char **argv
)
881 const char *record_args
[] = {
882 "record", "-R", "-m", "1024", "-c", "1",
884 unsigned int rec_argc
, i
, j
;
885 const char **rec_argv
;
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
);
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
);
900 rec_argv
= calloc(rec_argc
+ 1, sizeof(char *));
901 if (rec_argv
== NULL
)
904 for (i
= 0; i
< ARRAY_SIZE(record_args
); i
++)
905 rec_argv
[i
] = strdup(record_args
[i
]);
907 for (j
= 0; j
< ARRAY_SIZE(lock_tracepoints
); j
++) {
908 rec_argv
[i
++] = "-e";
909 rec_argv
[i
++] = strdup(lock_tracepoints
[j
].name
);
912 for (j
= 1; j
< (unsigned int)argc
; j
++, i
++)
913 rec_argv
[i
] = argv
[j
];
915 BUG_ON(i
!= rec_argc
);
917 return cmd_record(i
, rec_argv
, NULL
);
920 int cmd_lock(int argc
, const char **argv
, const char *prefix __maybe_unused
)
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)"),
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"),
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)"),
941 const char * const info_usage
[] = {
942 "perf lock info [<options>]",
945 const char * const lock_usage
[] = {
946 "perf lock [<options>] {record|report|script|info}",
949 const char * const report_usage
[] = {
950 "perf lock report [<options>]",
957 for (i
= 0; i
< LOCKHASH_SIZE
; i
++)
958 INIT_LIST_HEAD(lockhash_table
+ i
);
960 argc
= parse_options(argc
, argv
, lock_options
, lock_usage
,
961 PARSE_OPT_STOP_AT_NON_OPTION
);
963 usage_with_options(lock_usage
, lock_options
);
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
;
970 argc
= parse_options(argc
, argv
,
971 report_options
, report_usage
, 0);
973 usage_with_options(report_usage
, report_options
);
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")) {
981 argc
= parse_options(argc
, argv
,
982 info_options
, info_usage
, 0);
984 usage_with_options(info_usage
, info_options
);
986 /* recycling report_lock_ops */
987 trace_handler
= &report_lock_ops
;
989 if (read_events() != 0)
994 usage_with_options(lock_usage
, lock_options
);