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"
15 #include "util/tool.h"
17 #include <sys/types.h>
18 #include <sys/prctl.h>
19 #include <semaphore.h>
24 #include <linux/list.h>
25 #include <linux/hash.h>
27 static struct perf_session
*session
;
29 /* based on kernel/lockdep.c */
30 #define LOCKHASH_BITS 12
31 #define LOCKHASH_SIZE (1UL << LOCKHASH_BITS)
33 static struct list_head lockhash_table
[LOCKHASH_SIZE
];
35 #define __lockhashfn(key) hash_long((unsigned long)key, LOCKHASH_BITS)
36 #define lockhashentry(key) (lockhash_table + __lockhashfn((key)))
39 struct list_head hash_entry
;
40 struct rb_node rb
; /* used for sorting */
43 * FIXME: raw_field_value() returns unsigned long long,
44 * so address of lockdep_map should be dealed as 64bit.
45 * Is there more better solution?
47 void *addr
; /* address of lockdep_map, used as ID */
48 char *name
; /* for strcpy(), we cannot use const */
50 unsigned int nr_acquire
;
51 unsigned int nr_acquired
;
52 unsigned int nr_contended
;
53 unsigned int nr_release
;
55 unsigned int nr_readlock
;
56 unsigned int nr_trylock
;
57 /* these times are in nano sec. */
62 int discard
; /* flag of blacklist */
66 * States of lock_seq_stat
68 * UNINITIALIZED is required for detecting first event of acquire.
69 * As the nature of lock events, there is no guarantee
70 * that the first event for the locks are acquire,
71 * it can be acquired, contended or release.
73 #define SEQ_STATE_UNINITIALIZED 0 /* initial state */
74 #define SEQ_STATE_RELEASED 1
75 #define SEQ_STATE_ACQUIRING 2
76 #define SEQ_STATE_ACQUIRED 3
77 #define SEQ_STATE_READ_ACQUIRED 4
78 #define SEQ_STATE_CONTENDED 5
82 * Imported from include/linux/sched.h.
83 * Should this be synchronized?
85 #define MAX_LOCK_DEPTH 48
88 * struct lock_seq_stat:
89 * Place to put on state of one lock sequence
90 * 1) acquire -> acquired -> release
91 * 2) acquire -> contended -> acquired -> release
92 * 3) acquire (with read or try) -> release
93 * 4) Are there other patterns?
95 struct lock_seq_stat
{
96 struct list_head list
;
108 struct list_head seq_list
;
111 static struct rb_root thread_stats
;
113 static struct thread_stat
*thread_stat_find(u32 tid
)
115 struct rb_node
*node
;
116 struct thread_stat
*st
;
118 node
= thread_stats
.rb_node
;
120 st
= container_of(node
, struct thread_stat
, rb
);
123 else if (tid
< st
->tid
)
124 node
= node
->rb_left
;
126 node
= node
->rb_right
;
132 static void thread_stat_insert(struct thread_stat
*new)
134 struct rb_node
**rb
= &thread_stats
.rb_node
;
135 struct rb_node
*parent
= NULL
;
136 struct thread_stat
*p
;
139 p
= container_of(*rb
, struct thread_stat
, rb
);
142 if (new->tid
< p
->tid
)
143 rb
= &(*rb
)->rb_left
;
144 else if (new->tid
> p
->tid
)
145 rb
= &(*rb
)->rb_right
;
147 BUG_ON("inserting invalid thread_stat\n");
150 rb_link_node(&new->rb
, parent
, rb
);
151 rb_insert_color(&new->rb
, &thread_stats
);
154 static struct thread_stat
*thread_stat_findnew_after_first(u32 tid
)
156 struct thread_stat
*st
;
158 st
= thread_stat_find(tid
);
162 st
= zalloc(sizeof(struct thread_stat
));
164 die("memory allocation failed\n");
167 INIT_LIST_HEAD(&st
->seq_list
);
169 thread_stat_insert(st
);
174 static struct thread_stat
*thread_stat_findnew_first(u32 tid
);
175 static struct thread_stat
*(*thread_stat_findnew
)(u32 tid
) =
176 thread_stat_findnew_first
;
178 static struct thread_stat
*thread_stat_findnew_first(u32 tid
)
180 struct thread_stat
*st
;
182 st
= zalloc(sizeof(struct thread_stat
));
184 die("memory allocation failed\n");
186 INIT_LIST_HEAD(&st
->seq_list
);
188 rb_link_node(&st
->rb
, NULL
, &thread_stats
.rb_node
);
189 rb_insert_color(&st
->rb
, &thread_stats
);
191 thread_stat_findnew
= thread_stat_findnew_after_first
;
195 /* build simple key function one is bigger than two */
196 #define SINGLE_KEY(member) \
197 static int lock_stat_key_ ## member(struct lock_stat *one, \
198 struct lock_stat *two) \
200 return one->member > two->member; \
203 SINGLE_KEY(nr_acquired
)
204 SINGLE_KEY(nr_contended
)
205 SINGLE_KEY(wait_time_total
)
206 SINGLE_KEY(wait_time_max
)
208 static int lock_stat_key_wait_time_min(struct lock_stat
*one
,
209 struct lock_stat
*two
)
211 u64 s1
= one
->wait_time_min
;
212 u64 s2
= two
->wait_time_min
;
213 if (s1
== ULLONG_MAX
)
215 if (s2
== ULLONG_MAX
)
222 * name: the value for specify by user
223 * this should be simpler than raw name of member
224 * e.g. nr_acquired -> acquired, wait_time_total -> wait_total
227 int (*key
)(struct lock_stat
*, struct lock_stat
*);
230 static const char *sort_key
= "acquired";
232 static int (*compare
)(struct lock_stat
*, struct lock_stat
*);
234 static struct rb_root result
; /* place to store sorted data */
236 #define DEF_KEY_LOCK(name, fn_suffix) \
237 { #name, lock_stat_key_ ## fn_suffix }
238 struct lock_key keys
[] = {
239 DEF_KEY_LOCK(acquired
, nr_acquired
),
240 DEF_KEY_LOCK(contended
, nr_contended
),
241 DEF_KEY_LOCK(wait_total
, wait_time_total
),
242 DEF_KEY_LOCK(wait_min
, wait_time_min
),
243 DEF_KEY_LOCK(wait_max
, wait_time_max
),
245 /* extra comparisons much complicated should be here */
250 static void select_key(void)
254 for (i
= 0; keys
[i
].name
; i
++) {
255 if (!strcmp(keys
[i
].name
, sort_key
)) {
256 compare
= keys
[i
].key
;
261 die("Unknown compare key:%s\n", sort_key
);
264 static void insert_to_result(struct lock_stat
*st
,
265 int (*bigger
)(struct lock_stat
*, struct lock_stat
*))
267 struct rb_node
**rb
= &result
.rb_node
;
268 struct rb_node
*parent
= NULL
;
272 p
= container_of(*rb
, struct lock_stat
, rb
);
276 rb
= &(*rb
)->rb_left
;
278 rb
= &(*rb
)->rb_right
;
281 rb_link_node(&st
->rb
, parent
, rb
);
282 rb_insert_color(&st
->rb
, &result
);
285 /* returns left most element of result, and erase it */
286 static struct lock_stat
*pop_from_result(void)
288 struct rb_node
*node
= result
.rb_node
;
293 while (node
->rb_left
)
294 node
= node
->rb_left
;
296 rb_erase(node
, &result
);
297 return container_of(node
, struct lock_stat
, rb
);
300 static struct lock_stat
*lock_stat_findnew(void *addr
, const char *name
)
302 struct list_head
*entry
= lockhashentry(addr
);
303 struct lock_stat
*ret
, *new;
305 list_for_each_entry(ret
, entry
, hash_entry
) {
306 if (ret
->addr
== addr
)
310 new = zalloc(sizeof(struct lock_stat
));
315 new->name
= zalloc(sizeof(char) * strlen(name
) + 1);
318 strcpy(new->name
, name
);
320 new->wait_time_min
= ULLONG_MAX
;
322 list_add(&new->hash_entry
, entry
);
326 die("memory allocation failed\n");
329 static const char *input_name
;
331 struct raw_event_sample
{
336 struct trace_acquire_event
{
342 struct trace_acquired_event
{
347 struct trace_contended_event
{
352 struct trace_release_event
{
357 struct trace_lock_handler
{
358 void (*acquire_event
)(struct trace_acquire_event
*,
362 struct thread
*thread
);
364 void (*acquired_event
)(struct trace_acquired_event
*,
368 struct thread
*thread
);
370 void (*contended_event
)(struct trace_contended_event
*,
374 struct thread
*thread
);
376 void (*release_event
)(struct trace_release_event
*,
380 struct thread
*thread
);
383 static struct lock_seq_stat
*get_seq(struct thread_stat
*ts
, void *addr
)
385 struct lock_seq_stat
*seq
;
387 list_for_each_entry(seq
, &ts
->seq_list
, list
) {
388 if (seq
->addr
== addr
)
392 seq
= zalloc(sizeof(struct lock_seq_stat
));
394 die("Not enough memory\n");
395 seq
->state
= SEQ_STATE_UNINITIALIZED
;
398 list_add(&seq
->list
, &ts
->seq_list
);
410 static int bad_hist
[BROKEN_MAX
];
418 report_lock_acquire_event(struct trace_acquire_event
*acquire_event
,
419 struct event
*__event __used
,
421 u64 timestamp __used
,
422 struct thread
*thread __used
)
424 struct lock_stat
*ls
;
425 struct thread_stat
*ts
;
426 struct lock_seq_stat
*seq
;
428 ls
= lock_stat_findnew(acquire_event
->addr
, acquire_event
->name
);
432 ts
= thread_stat_findnew(thread
->pid
);
433 seq
= get_seq(ts
, acquire_event
->addr
);
435 switch (seq
->state
) {
436 case SEQ_STATE_UNINITIALIZED
:
437 case SEQ_STATE_RELEASED
:
438 if (!acquire_event
->flag
) {
439 seq
->state
= SEQ_STATE_ACQUIRING
;
441 if (acquire_event
->flag
& TRY_LOCK
)
443 if (acquire_event
->flag
& READ_LOCK
)
445 seq
->state
= SEQ_STATE_READ_ACQUIRED
;
450 case SEQ_STATE_READ_ACQUIRED
:
451 if (acquire_event
->flag
& READ_LOCK
) {
459 case SEQ_STATE_ACQUIRED
:
460 case SEQ_STATE_ACQUIRING
:
461 case SEQ_STATE_CONTENDED
:
463 /* broken lock sequence, discard it */
465 bad_hist
[BROKEN_ACQUIRE
]++;
466 list_del(&seq
->list
);
471 BUG_ON("Unknown state of lock sequence found!\n");
476 seq
->prev_event_time
= timestamp
;
482 report_lock_acquired_event(struct trace_acquired_event
*acquired_event
,
483 struct event
*__event __used
,
485 u64 timestamp __used
,
486 struct thread
*thread __used
)
488 struct lock_stat
*ls
;
489 struct thread_stat
*ts
;
490 struct lock_seq_stat
*seq
;
493 ls
= lock_stat_findnew(acquired_event
->addr
, acquired_event
->name
);
497 ts
= thread_stat_findnew(thread
->pid
);
498 seq
= get_seq(ts
, acquired_event
->addr
);
500 switch (seq
->state
) {
501 case SEQ_STATE_UNINITIALIZED
:
502 /* orphan event, do nothing */
504 case SEQ_STATE_ACQUIRING
:
506 case SEQ_STATE_CONTENDED
:
507 contended_term
= timestamp
- seq
->prev_event_time
;
508 ls
->wait_time_total
+= contended_term
;
509 if (contended_term
< ls
->wait_time_min
)
510 ls
->wait_time_min
= contended_term
;
511 if (ls
->wait_time_max
< contended_term
)
512 ls
->wait_time_max
= contended_term
;
514 case SEQ_STATE_RELEASED
:
515 case SEQ_STATE_ACQUIRED
:
516 case SEQ_STATE_READ_ACQUIRED
:
517 /* broken lock sequence, discard it */
519 bad_hist
[BROKEN_ACQUIRED
]++;
520 list_del(&seq
->list
);
526 BUG_ON("Unknown state of lock sequence found!\n");
530 seq
->state
= SEQ_STATE_ACQUIRED
;
532 seq
->prev_event_time
= timestamp
;
538 report_lock_contended_event(struct trace_contended_event
*contended_event
,
539 struct event
*__event __used
,
541 u64 timestamp __used
,
542 struct thread
*thread __used
)
544 struct lock_stat
*ls
;
545 struct thread_stat
*ts
;
546 struct lock_seq_stat
*seq
;
548 ls
= lock_stat_findnew(contended_event
->addr
, contended_event
->name
);
552 ts
= thread_stat_findnew(thread
->pid
);
553 seq
= get_seq(ts
, contended_event
->addr
);
555 switch (seq
->state
) {
556 case SEQ_STATE_UNINITIALIZED
:
557 /* orphan event, do nothing */
559 case SEQ_STATE_ACQUIRING
:
561 case SEQ_STATE_RELEASED
:
562 case SEQ_STATE_ACQUIRED
:
563 case SEQ_STATE_READ_ACQUIRED
:
564 case SEQ_STATE_CONTENDED
:
565 /* broken lock sequence, discard it */
567 bad_hist
[BROKEN_CONTENDED
]++;
568 list_del(&seq
->list
);
573 BUG_ON("Unknown state of lock sequence found!\n");
577 seq
->state
= SEQ_STATE_CONTENDED
;
579 seq
->prev_event_time
= timestamp
;
585 report_lock_release_event(struct trace_release_event
*release_event
,
586 struct event
*__event __used
,
588 u64 timestamp __used
,
589 struct thread
*thread __used
)
591 struct lock_stat
*ls
;
592 struct thread_stat
*ts
;
593 struct lock_seq_stat
*seq
;
595 ls
= lock_stat_findnew(release_event
->addr
, release_event
->name
);
599 ts
= thread_stat_findnew(thread
->pid
);
600 seq
= get_seq(ts
, release_event
->addr
);
602 switch (seq
->state
) {
603 case SEQ_STATE_UNINITIALIZED
:
606 case SEQ_STATE_ACQUIRED
:
608 case SEQ_STATE_READ_ACQUIRED
:
610 BUG_ON(seq
->read_count
< 0);
611 if (!seq
->read_count
) {
616 case SEQ_STATE_ACQUIRING
:
617 case SEQ_STATE_CONTENDED
:
618 case SEQ_STATE_RELEASED
:
619 /* broken lock sequence, discard it */
621 bad_hist
[BROKEN_RELEASE
]++;
625 BUG_ON("Unknown state of lock sequence found!\n");
631 list_del(&seq
->list
);
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
,
646 static struct trace_lock_handler
*trace_handler
;
649 process_lock_acquire_event(void *data
,
650 struct event
*event __used
,
652 u64 timestamp __used
,
653 struct thread
*thread __used
)
655 struct trace_acquire_event acquire_event
;
656 u64 tmp
; /* this is required for casting... */
658 tmp
= raw_field_value(event
, "lockdep_addr", data
);
659 memcpy(&acquire_event
.addr
, &tmp
, sizeof(void *));
660 acquire_event
.name
= (char *)raw_field_ptr(event
, "name", data
);
661 acquire_event
.flag
= (int)raw_field_value(event
, "flag", data
);
663 if (trace_handler
->acquire_event
)
664 trace_handler
->acquire_event(&acquire_event
, event
, cpu
, timestamp
, thread
);
668 process_lock_acquired_event(void *data
,
669 struct event
*event __used
,
671 u64 timestamp __used
,
672 struct thread
*thread __used
)
674 struct trace_acquired_event acquired_event
;
675 u64 tmp
; /* this is required for casting... */
677 tmp
= raw_field_value(event
, "lockdep_addr", data
);
678 memcpy(&acquired_event
.addr
, &tmp
, sizeof(void *));
679 acquired_event
.name
= (char *)raw_field_ptr(event
, "name", data
);
681 if (trace_handler
->acquire_event
)
682 trace_handler
->acquired_event(&acquired_event
, event
, cpu
, timestamp
, thread
);
686 process_lock_contended_event(void *data
,
687 struct event
*event __used
,
689 u64 timestamp __used
,
690 struct thread
*thread __used
)
692 struct trace_contended_event contended_event
;
693 u64 tmp
; /* this is required for casting... */
695 tmp
= raw_field_value(event
, "lockdep_addr", data
);
696 memcpy(&contended_event
.addr
, &tmp
, sizeof(void *));
697 contended_event
.name
= (char *)raw_field_ptr(event
, "name", data
);
699 if (trace_handler
->acquire_event
)
700 trace_handler
->contended_event(&contended_event
, event
, cpu
, timestamp
, thread
);
704 process_lock_release_event(void *data
,
705 struct event
*event __used
,
707 u64 timestamp __used
,
708 struct thread
*thread __used
)
710 struct trace_release_event release_event
;
711 u64 tmp
; /* this is required for casting... */
713 tmp
= raw_field_value(event
, "lockdep_addr", data
);
714 memcpy(&release_event
.addr
, &tmp
, sizeof(void *));
715 release_event
.name
= (char *)raw_field_ptr(event
, "name", data
);
717 if (trace_handler
->acquire_event
)
718 trace_handler
->release_event(&release_event
, event
, cpu
, timestamp
, thread
);
722 process_raw_event(void *data
, int cpu
, u64 timestamp
, struct thread
*thread
)
727 type
= trace_parse_common_type(data
);
728 event
= trace_find_event(type
);
730 if (!strcmp(event
->name
, "lock_acquire"))
731 process_lock_acquire_event(data
, event
, cpu
, timestamp
, thread
);
732 if (!strcmp(event
->name
, "lock_acquired"))
733 process_lock_acquired_event(data
, event
, cpu
, timestamp
, thread
);
734 if (!strcmp(event
->name
, "lock_contended"))
735 process_lock_contended_event(data
, event
, cpu
, timestamp
, thread
);
736 if (!strcmp(event
->name
, "lock_release"))
737 process_lock_release_event(data
, event
, cpu
, timestamp
, thread
);
740 static void print_bad_events(int bad
, int total
)
742 /* Output for debug, this have to be removed */
744 const char *name
[4] =
745 { "acquire", "acquired", "contended", "release" };
747 pr_info("\n=== output for debug===\n\n");
748 pr_info("bad: %d, total: %d\n", bad
, total
);
749 pr_info("bad rate: %f %%\n", (double)bad
/ (double)total
* 100);
750 pr_info("histogram of events caused bad sequence\n");
751 for (i
= 0; i
< BROKEN_MAX
; i
++)
752 pr_info(" %10s: %d\n", name
[i
], bad_hist
[i
]);
755 /* TODO: various way to print, coloring, nano or milli sec */
756 static void print_result(void)
758 struct lock_stat
*st
;
762 pr_info("%20s ", "Name");
763 pr_info("%10s ", "acquired");
764 pr_info("%10s ", "contended");
766 pr_info("%15s ", "total wait (ns)");
767 pr_info("%15s ", "max wait (ns)");
768 pr_info("%15s ", "min wait (ns)");
773 while ((st
= pop_from_result())) {
781 if (strlen(st
->name
) < 16) {
782 /* output raw name */
783 pr_info("%20s ", st
->name
);
785 strncpy(cut_name
, st
->name
, 16);
790 /* cut off name for saving output style */
791 pr_info("%20s ", cut_name
);
794 pr_info("%10u ", st
->nr_acquired
);
795 pr_info("%10u ", st
->nr_contended
);
797 pr_info("%15" PRIu64
" ", st
->wait_time_total
);
798 pr_info("%15" PRIu64
" ", st
->wait_time_max
);
799 pr_info("%15" PRIu64
" ", st
->wait_time_min
== ULLONG_MAX
?
800 0 : st
->wait_time_min
);
804 print_bad_events(bad
, total
);
807 static bool info_threads
, info_map
;
809 static void dump_threads(void)
811 struct thread_stat
*st
;
812 struct rb_node
*node
;
815 pr_info("%10s: comm\n", "Thread ID");
817 node
= rb_first(&thread_stats
);
819 st
= container_of(node
, struct thread_stat
, rb
);
820 t
= perf_session__findnew(session
, st
->tid
);
821 pr_info("%10d: %s\n", st
->tid
, t
->comm
);
822 node
= rb_next(node
);
826 static void dump_map(void)
829 struct lock_stat
*st
;
831 pr_info("Address of instance: name of class\n");
832 for (i
= 0; i
< LOCKHASH_SIZE
; i
++) {
833 list_for_each_entry(st
, &lockhash_table
[i
], hash_entry
) {
834 pr_info(" %p: %s\n", st
->addr
, st
->name
);
839 static void dump_info(void)
846 die("Unknown type of information\n");
849 static int process_sample_event(struct perf_tool
*tool __used
,
850 union perf_event
*event
,
851 struct perf_sample
*sample
,
852 struct perf_evsel
*evsel __used
,
853 struct machine
*machine
)
855 struct thread
*thread
= machine__findnew_thread(machine
, sample
->tid
);
857 if (thread
== NULL
) {
858 pr_debug("problem processing %d event, skipping it.\n",
863 process_raw_event(sample
->raw_data
, sample
->cpu
, sample
->time
, thread
);
868 static struct perf_tool eops
= {
869 .sample
= process_sample_event
,
870 .comm
= perf_event__process_comm
,
871 .ordered_samples
= true,
874 static int read_events(void)
876 session
= perf_session__new(input_name
, O_RDONLY
, 0, false, &eops
);
878 die("Initializing perf session failed\n");
880 return perf_session__process_events(session
, &eops
);
883 static void sort_result(void)
886 struct lock_stat
*st
;
888 for (i
= 0; i
< LOCKHASH_SIZE
; i
++) {
889 list_for_each_entry(st
, &lockhash_table
[i
], hash_entry
) {
890 insert_to_result(st
, compare
);
895 static void __cmd_report(void)
904 static const char * const report_usage
[] = {
905 "perf lock report [<options>]",
909 static const struct option report_options
[] = {
910 OPT_STRING('k', "key", &sort_key
, "acquired",
911 "key for sorting (acquired / contended / wait_total / wait_max / wait_min)"),
916 static const char * const info_usage
[] = {
917 "perf lock info [<options>]",
921 static 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 (name:address table)"),
929 static const char * const lock_usage
[] = {
930 "perf lock [<options>] {record|trace|report}",
934 static const struct option lock_options
[] = {
935 OPT_STRING('i', "input", &input_name
, "file", "input file name"),
936 OPT_INCR('v', "verbose", &verbose
, "be more verbose (show symbol address, etc)"),
937 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace
, "dump raw trace in ASCII"),
941 static const char *record_args
[] = {
947 "-e", "lock:lock_acquire",
948 "-e", "lock:lock_acquired",
949 "-e", "lock:lock_contended",
950 "-e", "lock:lock_release",
953 static int __cmd_record(int argc
, const char **argv
)
955 unsigned int rec_argc
, i
, j
;
956 const char **rec_argv
;
958 rec_argc
= ARRAY_SIZE(record_args
) + argc
- 1;
959 rec_argv
= calloc(rec_argc
+ 1, sizeof(char *));
961 if (rec_argv
== NULL
)
964 for (i
= 0; i
< ARRAY_SIZE(record_args
); i
++)
965 rec_argv
[i
] = strdup(record_args
[i
]);
967 for (j
= 1; j
< (unsigned int)argc
; j
++, i
++)
968 rec_argv
[i
] = argv
[j
];
970 BUG_ON(i
!= rec_argc
);
972 return cmd_record(i
, rec_argv
, NULL
);
975 int cmd_lock(int argc
, const char **argv
, const char *prefix __used
)
980 for (i
= 0; i
< LOCKHASH_SIZE
; i
++)
981 INIT_LIST_HEAD(lockhash_table
+ i
);
983 argc
= parse_options(argc
, argv
, lock_options
, lock_usage
,
984 PARSE_OPT_STOP_AT_NON_OPTION
);
986 usage_with_options(lock_usage
, lock_options
);
988 if (!strncmp(argv
[0], "rec", 3)) {
989 return __cmd_record(argc
, argv
);
990 } else if (!strncmp(argv
[0], "report", 6)) {
991 trace_handler
= &report_lock_ops
;
993 argc
= parse_options(argc
, argv
,
994 report_options
, report_usage
, 0);
996 usage_with_options(report_usage
, report_options
);
999 } else if (!strcmp(argv
[0], "script")) {
1000 /* Aliased to 'perf script' */
1001 return cmd_script(argc
, argv
, prefix
);
1002 } else if (!strcmp(argv
[0], "info")) {
1004 argc
= parse_options(argc
, argv
,
1005 info_options
, info_usage
, 0);
1007 usage_with_options(info_usage
, info_options
);
1009 /* recycling report_lock_ops */
1010 trace_handler
= &report_lock_ops
;
1015 usage_with_options(lock_usage
, lock_options
);