~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/builtin-lock.c

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #include "builtin.h"
  2 #include "perf.h"
  3 
  4 #include "util/evlist.h"
  5 #include "util/evsel.h"
  6 #include "util/util.h"
  7 #include "util/cache.h"
  8 #include "util/symbol.h"
  9 #include "util/thread.h"
 10 #include "util/header.h"
 11 
 12 #include "util/parse-options.h"
 13 #include "util/trace-event.h"
 14 
 15 #include "util/debug.h"
 16 #include "util/session.h"
 17 #include "util/tool.h"
 18 
 19 #include <sys/types.h>
 20 #include <sys/prctl.h>
 21 #include <semaphore.h>
 22 #include <pthread.h>
 23 #include <math.h>
 24 #include <limits.h>
 25 
 26 #include <linux/list.h>
 27 #include <linux/hash.h>
 28 
 29 static struct perf_session *session;
 30 
 31 /* based on kernel/lockdep.c */
 32 #define LOCKHASH_BITS           12
 33 #define LOCKHASH_SIZE           (1UL << LOCKHASH_BITS)
 34 
 35 static struct list_head lockhash_table[LOCKHASH_SIZE];
 36 
 37 #define __lockhashfn(key)       hash_long((unsigned long)key, LOCKHASH_BITS)
 38 #define lockhashentry(key)      (lockhash_table + __lockhashfn((key)))
 39 
 40 struct lock_stat {
 41         struct list_head        hash_entry;
 42         struct rb_node          rb;             /* used for sorting */
 43 
 44         /*
 45          * FIXME: perf_evsel__intval() returns u64,
 46          * so address of lockdep_map should be dealed as 64bit.
 47          * Is there more better solution?
 48          */
 49         void                    *addr;          /* address of lockdep_map, used as ID */
 50         char                    *name;          /* for strcpy(), we cannot use const */
 51 
 52         unsigned int            nr_acquire;
 53         unsigned int            nr_acquired;
 54         unsigned int            nr_contended;
 55         unsigned int            nr_release;
 56 
 57         unsigned int            nr_readlock;
 58         unsigned int            nr_trylock;
 59         /* these times are in nano sec. */
 60         u64                     wait_time_total;
 61         u64                     wait_time_min;
 62         u64                     wait_time_max;
 63 
 64         int                     discard; /* flag of blacklist */
 65 };
 66 
 67 /*
 68  * States of lock_seq_stat
 69  *
 70  * UNINITIALIZED is required for detecting first event of acquire.
 71  * As the nature of lock events, there is no guarantee
 72  * that the first event for the locks are acquire,
 73  * it can be acquired, contended or release.
 74  */
 75 #define SEQ_STATE_UNINITIALIZED      0         /* initial state */
 76 #define SEQ_STATE_RELEASED      1
 77 #define SEQ_STATE_ACQUIRING     2
 78 #define SEQ_STATE_ACQUIRED      3
 79 #define SEQ_STATE_READ_ACQUIRED 4
 80 #define SEQ_STATE_CONTENDED     5
 81 
 82 /*
 83  * MAX_LOCK_DEPTH
 84  * Imported from include/linux/sched.h.
 85  * Should this be synchronized?
 86  */
 87 #define MAX_LOCK_DEPTH 48
 88 
 89 /*
 90  * struct lock_seq_stat:
 91  * Place to put on state of one lock sequence
 92  * 1) acquire -> acquired -> release
 93  * 2) acquire -> contended -> acquired -> release
 94  * 3) acquire (with read or try) -> release
 95  * 4) Are there other patterns?
 96  */
 97 struct lock_seq_stat {
 98         struct list_head        list;
 99         int                     state;
100         u64                     prev_event_time;
101         void                    *addr;
102 
103         int                     read_count;
104 };
105 
106 struct thread_stat {
107         struct rb_node          rb;
108 
109         u32                     tid;
110         struct list_head        seq_list;
111 };
112 
113 static struct rb_root           thread_stats;
114 
115 static struct thread_stat *thread_stat_find(u32 tid)
116 {
117         struct rb_node *node;
118         struct thread_stat *st;
119 
120         node = thread_stats.rb_node;
121         while (node) {
122                 st = container_of(node, struct thread_stat, rb);
123                 if (st->tid == tid)
124                         return st;
125                 else if (tid < st->tid)
126                         node = node->rb_left;
127                 else
128                         node = node->rb_right;
129         }
130 
131         return NULL;
132 }
133 
134 static void thread_stat_insert(struct thread_stat *new)
135 {
136         struct rb_node **rb = &thread_stats.rb_node;
137         struct rb_node *parent = NULL;
138         struct thread_stat *p;
139 
140         while (*rb) {
141                 p = container_of(*rb, struct thread_stat, rb);
142                 parent = *rb;
143 
144                 if (new->tid < p->tid)
145                         rb = &(*rb)->rb_left;
146                 else if (new->tid > p->tid)
147                         rb = &(*rb)->rb_right;
148                 else
149                         BUG_ON("inserting invalid thread_stat\n");
150         }
151 
152         rb_link_node(&new->rb, parent, rb);
153         rb_insert_color(&new->rb, &thread_stats);
154 }
155 
156 static struct thread_stat *thread_stat_findnew_after_first(u32 tid)
157 {
158         struct thread_stat *st;
159 
160         st = thread_stat_find(tid);
161         if (st)
162                 return st;
163 
164         st = zalloc(sizeof(struct thread_stat));
165         if (!st) {
166                 pr_err("memory allocation failed\n");
167                 return NULL;
168         }
169 
170         st->tid = tid;
171         INIT_LIST_HEAD(&st->seq_list);
172 
173         thread_stat_insert(st);
174 
175         return st;
176 }
177 
178 static struct thread_stat *thread_stat_findnew_first(u32 tid);
179 static struct thread_stat *(*thread_stat_findnew)(u32 tid) =
180         thread_stat_findnew_first;
181 
182 static struct thread_stat *thread_stat_findnew_first(u32 tid)
183 {
184         struct thread_stat *st;
185 
186         st = zalloc(sizeof(struct thread_stat));
187         if (!st) {
188                 pr_err("memory allocation failed\n");
189                 return NULL;
190         }
191         st->tid = tid;
192         INIT_LIST_HEAD(&st->seq_list);
193 
194         rb_link_node(&st->rb, NULL, &thread_stats.rb_node);
195         rb_insert_color(&st->rb, &thread_stats);
196 
197         thread_stat_findnew = thread_stat_findnew_after_first;
198         return st;
199 }
200 
201 /* build simple key function one is bigger than two */
202 #define SINGLE_KEY(member)                                              \
203         static int lock_stat_key_ ## member(struct lock_stat *one,      \
204                                          struct lock_stat *two)         \
205         {                                                               \
206                 return one->member > two->member;                       \
207         }
208 
209 SINGLE_KEY(nr_acquired)
210 SINGLE_KEY(nr_contended)
211 SINGLE_KEY(wait_time_total)
212 SINGLE_KEY(wait_time_max)
213 
214 static int lock_stat_key_wait_time_min(struct lock_stat *one,
215                                         struct lock_stat *two)
216 {
217         u64 s1 = one->wait_time_min;
218         u64 s2 = two->wait_time_min;
219         if (s1 == ULLONG_MAX)
220                 s1 = 0;
221         if (s2 == ULLONG_MAX)
222                 s2 = 0;
223         return s1 > s2;
224 }
225 
226 struct lock_key {
227         /*
228          * name: the value for specify by user
229          * this should be simpler than raw name of member
230          * e.g. nr_acquired -> acquired, wait_time_total -> wait_total
231          */
232         const char              *name;
233         int                     (*key)(struct lock_stat*, struct lock_stat*);
234 };
235 
236 static const char               *sort_key = "acquired";
237 
238 static int                      (*compare)(struct lock_stat *, struct lock_stat *);
239 
240 static struct rb_root           result; /* place to store sorted data */
241 
242 #define DEF_KEY_LOCK(name, fn_suffix)   \
243         { #name, lock_stat_key_ ## fn_suffix }
244 struct lock_key keys[] = {
245         DEF_KEY_LOCK(acquired, nr_acquired),
246         DEF_KEY_LOCK(contended, nr_contended),
247         DEF_KEY_LOCK(wait_total, wait_time_total),
248         DEF_KEY_LOCK(wait_min, wait_time_min),
249         DEF_KEY_LOCK(wait_max, wait_time_max),
250 
251         /* extra comparisons much complicated should be here */
252 
253         { NULL, NULL }
254 };
255 
256 static int select_key(void)
257 {
258         int i;
259 
260         for (i = 0; keys[i].name; i++) {
261                 if (!strcmp(keys[i].name, sort_key)) {
262                         compare = keys[i].key;
263                         return 0;
264                 }
265         }
266 
267         pr_err("Unknown compare key: %s\n", sort_key);
268 
269         return -1;
270 }
271 
272 static void insert_to_result(struct lock_stat *st,
273                              int (*bigger)(struct lock_stat *, struct lock_stat *))
274 {
275         struct rb_node **rb = &result.rb_node;
276         struct rb_node *parent = NULL;
277         struct lock_stat *p;
278 
279         while (*rb) {
280                 p = container_of(*rb, struct lock_stat, rb);
281                 parent = *rb;
282 
283                 if (bigger(st, p))
284                         rb = &(*rb)->rb_left;
285                 else
286                         rb = &(*rb)->rb_right;
287         }
288 
289         rb_link_node(&st->rb, parent, rb);
290         rb_insert_color(&st->rb, &result);
291 }
292 
293 /* returns left most element of result, and erase it */
294 static struct lock_stat *pop_from_result(void)
295 {
296         struct rb_node *node = result.rb_node;
297 
298         if (!node)
299                 return NULL;
300 
301         while (node->rb_left)
302                 node = node->rb_left;
303 
304         rb_erase(node, &result);
305         return container_of(node, struct lock_stat, rb);
306 }
307 
308 static struct lock_stat *lock_stat_findnew(void *addr, const char *name)
309 {
310         struct list_head *entry = lockhashentry(addr);
311         struct lock_stat *ret, *new;
312 
313         list_for_each_entry(ret, entry, hash_entry) {
314                 if (ret->addr == addr)
315                         return ret;
316         }
317 
318         new = zalloc(sizeof(struct lock_stat));
319         if (!new)
320                 goto alloc_failed;
321 
322         new->addr = addr;
323         new->name = zalloc(sizeof(char) * strlen(name) + 1);
324         if (!new->name)
325                 goto alloc_failed;
326         strcpy(new->name, name);
327 
328         new->wait_time_min = ULLONG_MAX;
329 
330         list_add(&new->hash_entry, entry);
331         return new;
332 
333 alloc_failed:
334         pr_err("memory allocation failed\n");
335         return NULL;
336 }
337 
338 struct trace_lock_handler {
339         int (*acquire_event)(struct perf_evsel *evsel,
340                              struct perf_sample *sample);
341 
342         int (*acquired_event)(struct perf_evsel *evsel,
343                               struct perf_sample *sample);
344 
345         int (*contended_event)(struct perf_evsel *evsel,
346                                struct perf_sample *sample);
347 
348         int (*release_event)(struct perf_evsel *evsel,
349                              struct perf_sample *sample);
350 };
351 
352 static struct lock_seq_stat *get_seq(struct thread_stat *ts, void *addr)
353 {
354         struct lock_seq_stat *seq;
355 
356         list_for_each_entry(seq, &ts->seq_list, list) {
357                 if (seq->addr == addr)
358                         return seq;
359         }
360 
361         seq = zalloc(sizeof(struct lock_seq_stat));
362         if (!seq) {
363                 pr_err("memory allocation failed\n");
364                 return NULL;
365         }
366         seq->state = SEQ_STATE_UNINITIALIZED;
367         seq->addr = addr;
368 
369         list_add(&seq->list, &ts->seq_list);
370         return seq;
371 }
372 
373 enum broken_state {
374         BROKEN_ACQUIRE,
375         BROKEN_ACQUIRED,
376         BROKEN_CONTENDED,
377         BROKEN_RELEASE,
378         BROKEN_MAX,
379 };
380 
381 static int bad_hist[BROKEN_MAX];
382 
383 enum acquire_flags {
384         TRY_LOCK = 1,
385         READ_LOCK = 2,
386 };
387 
388 static int report_lock_acquire_event(struct perf_evsel *evsel,
389                                      struct perf_sample *sample)
390 {
391         void *addr;
392         struct lock_stat *ls;
393         struct thread_stat *ts;
394         struct lock_seq_stat *seq;
395         const char *name = perf_evsel__strval(evsel, sample, "name");
396         u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr");
397         int flag = perf_evsel__intval(evsel, sample, "flag");
398 
399         memcpy(&addr, &tmp, sizeof(void *));
400 
401         ls = lock_stat_findnew(addr, name);
402         if (!ls)
403                 return -1;
404         if (ls->discard)
405                 return 0;
406 
407         ts = thread_stat_findnew(sample->tid);
408         if (!ts)
409                 return -1;
410 
411         seq = get_seq(ts, addr);
412         if (!seq)
413                 return -1;
414 
415         switch (seq->state) {
416         case SEQ_STATE_UNINITIALIZED:
417         case SEQ_STATE_RELEASED:
418                 if (!flag) {
419                         seq->state = SEQ_STATE_ACQUIRING;
420                 } else {
421                         if (flag & TRY_LOCK)
422                                 ls->nr_trylock++;
423                         if (flag & READ_LOCK)
424                                 ls->nr_readlock++;
425                         seq->state = SEQ_STATE_READ_ACQUIRED;
426                         seq->read_count = 1;
427                         ls->nr_acquired++;
428                 }
429                 break;
430         case SEQ_STATE_READ_ACQUIRED:
431                 if (flag & READ_LOCK) {
432                         seq->read_count++;
433                         ls->nr_acquired++;
434                         goto end;
435                 } else {
436                         goto broken;
437                 }
438                 break;
439         case SEQ_STATE_ACQUIRED:
440         case SEQ_STATE_ACQUIRING:
441         case SEQ_STATE_CONTENDED:
442 broken:
443                 /* broken lock sequence, discard it */
444                 ls->discard = 1;
445                 bad_hist[BROKEN_ACQUIRE]++;
446                 list_del(&seq->list);
447                 free(seq);
448                 goto end;
449                 break;
450         default:
451                 BUG_ON("Unknown state of lock sequence found!\n");
452                 break;
453         }
454 
455         ls->nr_acquire++;
456         seq->prev_event_time = sample->time;
457 end:
458         return 0;
459 }
460 
461 static int report_lock_acquired_event(struct perf_evsel *evsel,
462                                       struct perf_sample *sample)
463 {
464         void *addr;
465         struct lock_stat *ls;
466         struct thread_stat *ts;
467         struct lock_seq_stat *seq;
468         u64 contended_term;
469         const char *name = perf_evsel__strval(evsel, sample, "name");
470         u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr");
471 
472         memcpy(&addr, &tmp, sizeof(void *));
473 
474         ls = lock_stat_findnew(addr, name);
475         if (!ls)
476                 return -1;
477         if (ls->discard)
478                 return 0;
479 
480         ts = thread_stat_findnew(sample->tid);
481         if (!ts)
482                 return -1;
483 
484         seq = get_seq(ts, addr);
485         if (!seq)
486                 return -1;
487 
488         switch (seq->state) {
489         case SEQ_STATE_UNINITIALIZED:
490                 /* orphan event, do nothing */
491                 return 0;
492         case SEQ_STATE_ACQUIRING:
493                 break;
494         case SEQ_STATE_CONTENDED:
495                 contended_term = sample->time - seq->prev_event_time;
496                 ls->wait_time_total += contended_term;
497                 if (contended_term < ls->wait_time_min)
498                         ls->wait_time_min = contended_term;
499                 if (ls->wait_time_max < contended_term)
500                         ls->wait_time_max = contended_term;
501                 break;
502         case SEQ_STATE_RELEASED:
503         case SEQ_STATE_ACQUIRED:
504         case SEQ_STATE_READ_ACQUIRED:
505                 /* broken lock sequence, discard it */
506                 ls->discard = 1;
507                 bad_hist[BROKEN_ACQUIRED]++;
508                 list_del(&seq->list);
509                 free(seq);
510                 goto end;
511                 break;
512 
513         default:
514                 BUG_ON("Unknown state of lock sequence found!\n");
515                 break;
516         }
517 
518         seq->state = SEQ_STATE_ACQUIRED;
519         ls->nr_acquired++;
520         seq->prev_event_time = sample->time;
521 end:
522         return 0;
523 }
524 
525 static int report_lock_contended_event(struct perf_evsel *evsel,
526                                        struct perf_sample *sample)
527 {
528         void *addr;
529         struct lock_stat *ls;
530         struct thread_stat *ts;
531         struct lock_seq_stat *seq;
532         const char *name = perf_evsel__strval(evsel, sample, "name");
533         u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr");
534 
535         memcpy(&addr, &tmp, sizeof(void *));
536 
537         ls = lock_stat_findnew(addr, name);
538         if (!ls)
539                 return -1;
540         if (ls->discard)
541                 return 0;
542 
543         ts = thread_stat_findnew(sample->tid);
544         if (!ts)
545                 return -1;
546 
547         seq = get_seq(ts, addr);
548         if (!seq)
549                 return -1;
550 
551         switch (seq->state) {
552         case SEQ_STATE_UNINITIALIZED:
553                 /* orphan event, do nothing */
554                 return 0;
555         case SEQ_STATE_ACQUIRING:
556                 break;
557         case SEQ_STATE_RELEASED:
558         case SEQ_STATE_ACQUIRED:
559         case SEQ_STATE_READ_ACQUIRED:
560         case SEQ_STATE_CONTENDED:
561                 /* broken lock sequence, discard it */
562                 ls->discard = 1;
563                 bad_hist[BROKEN_CONTENDED]++;
564                 list_del(&seq->list);
565                 free(seq);
566                 goto end;
567                 break;
568         default:
569                 BUG_ON("Unknown state of lock sequence found!\n");
570                 break;
571         }
572 
573         seq->state = SEQ_STATE_CONTENDED;
574         ls->nr_contended++;
575         seq->prev_event_time = sample->time;
576 end:
577         return 0;
578 }
579 
580 static int report_lock_release_event(struct perf_evsel *evsel,
581                                      struct perf_sample *sample)
582 {
583         void *addr;
584         struct lock_stat *ls;
585         struct thread_stat *ts;
586         struct lock_seq_stat *seq;
587         const char *name = perf_evsel__strval(evsel, sample, "name");
588         u64 tmp = perf_evsel__intval(evsel, sample, "lockdep_addr");
589 
590         memcpy(&addr, &tmp, sizeof(void *));
591 
592         ls = lock_stat_findnew(addr, name);
593         if (!ls)
594                 return -1;
595         if (ls->discard)
596                 return 0;
597 
598         ts = thread_stat_findnew(sample->tid);
599         if (!ts)
600                 return -1;
601 
602         seq = get_seq(ts, addr);
603         if (!seq)
604                 return -1;
605 
606         switch (seq->state) {
607         case SEQ_STATE_UNINITIALIZED:
608                 goto end;
609                 break;
610         case SEQ_STATE_ACQUIRED:
611                 break;
612         case SEQ_STATE_READ_ACQUIRED:
613                 seq->read_count--;
614                 BUG_ON(seq->read_count < 0);
615                 if (!seq->read_count) {
616                         ls->nr_release++;
617                         goto end;
618                 }
619                 break;
620         case SEQ_STATE_ACQUIRING:
621         case SEQ_STATE_CONTENDED:
622         case SEQ_STATE_RELEASED:
623                 /* broken lock sequence, discard it */
624                 ls->discard = 1;
625                 bad_hist[BROKEN_RELEASE]++;
626                 goto free_seq;
627                 break;
628         default:
629                 BUG_ON("Unknown state of lock sequence found!\n");
630                 break;
631         }
632 
633         ls->nr_release++;
634 free_seq:
635         list_del(&seq->list);
636         free(seq);
637 end:
638         return 0;
639 }
640 
641 /* lock oriented handlers */
642 /* TODO: handlers for CPU oriented, thread oriented */
643 static struct trace_lock_handler report_lock_ops  = {
644         .acquire_event          = report_lock_acquire_event,
645         .acquired_event         = report_lock_acquired_event,
646         .contended_event        = report_lock_contended_event,
647         .release_event          = report_lock_release_event,
648 };
649 
650 static struct trace_lock_handler *trace_handler;
651 
652 static int perf_evsel__process_lock_acquire(struct perf_evsel *evsel,
653                                              struct perf_sample *sample)
654 {
655         if (trace_handler->acquire_event)
656                 return trace_handler->acquire_event(evsel, sample);
657         return 0;
658 }
659 
660 static int perf_evsel__process_lock_acquired(struct perf_evsel *evsel,
661                                               struct perf_sample *sample)
662 {
663         if (trace_handler->acquired_event)
664                 return trace_handler->acquired_event(evsel, sample);
665         return 0;
666 }
667 
668 static int perf_evsel__process_lock_contended(struct perf_evsel *evsel,
669                                               struct perf_sample *sample)
670 {
671         if (trace_handler->contended_event)
672                 return trace_handler->contended_event(evsel, sample);
673         return 0;
674 }
675 
676 static int perf_evsel__process_lock_release(struct perf_evsel *evsel,
677                                             struct perf_sample *sample)
678 {
679         if (trace_handler->release_event)
680                 return trace_handler->release_event(evsel, sample);
681         return 0;
682 }
683 
684 static void print_bad_events(int bad, int total)
685 {
686         /* Output for debug, this have to be removed */
687         int i;
688         const char *name[4] =
689                 { "acquire", "acquired", "contended", "release" };
690 
691         pr_info("\n=== output for debug===\n\n");
692         pr_info("bad: %d, total: %d\n", bad, total);
693         pr_info("bad rate: %f %%\n", (double)bad / (double)total * 100);
694         pr_info("histogram of events caused bad sequence\n");
695         for (i = 0; i < BROKEN_MAX; i++)
696                 pr_info(" %10s: %d\n", name[i], bad_hist[i]);
697 }
698 
699 /* TODO: various way to print, coloring, nano or milli sec */
700 static void print_result(void)
701 {
702         struct lock_stat *st;
703         char cut_name[20];
704         int bad, total;
705 
706         pr_info("%20s ", "Name");
707         pr_info("%10s ", "acquired");
708         pr_info("%10s ", "contended");
709 
710         pr_info("%15s ", "total wait (ns)");
711         pr_info("%15s ", "max wait (ns)");
712         pr_info("%15s ", "min wait (ns)");
713 
714         pr_info("\n\n");
715 
716         bad = total = 0;
717         while ((st = pop_from_result())) {
718                 total++;
719                 if (st->discard) {
720                         bad++;
721                         continue;
722                 }
723                 bzero(cut_name, 20);
724 
725                 if (strlen(st->name) < 16) {
726                         /* output raw name */
727                         pr_info("%20s ", st->name);
728                 } else {
729                         strncpy(cut_name, st->name, 16);
730                         cut_name[16] = '.';
731                         cut_name[17] = '.';
732                         cut_name[18] = '.';
733                         cut_name[19] = '\0';
734                         /* cut off name for saving output style */
735                         pr_info("%20s ", cut_name);
736                 }
737 
738                 pr_info("%10u ", st->nr_acquired);
739                 pr_info("%10u ", st->nr_contended);
740 
741                 pr_info("%15" PRIu64 " ", st->wait_time_total);
742                 pr_info("%15" PRIu64 " ", st->wait_time_max);
743                 pr_info("%15" PRIu64 " ", st->wait_time_min == ULLONG_MAX ?
744                        0 : st->wait_time_min);
745                 pr_info("\n");
746         }
747 
748         print_bad_events(bad, total);
749 }
750 
751 static bool info_threads, info_map;
752 
753 static void dump_threads(void)
754 {
755         struct thread_stat *st;
756         struct rb_node *node;
757         struct thread *t;
758 
759         pr_info("%10s: comm\n", "Thread ID");
760 
761         node = rb_first(&thread_stats);
762         while (node) {
763                 st = container_of(node, struct thread_stat, rb);
764                 t = perf_session__findnew(session, st->tid);
765                 pr_info("%10d: %s\n", st->tid, t->comm);
766                 node = rb_next(node);
767         };
768 }
769 
770 static void dump_map(void)
771 {
772         unsigned int i;
773         struct lock_stat *st;
774 
775         pr_info("Address of instance: name of class\n");
776         for (i = 0; i < LOCKHASH_SIZE; i++) {
777                 list_for_each_entry(st, &lockhash_table[i], hash_entry) {
778                         pr_info(" %p: %s\n", st->addr, st->name);
779                 }
780         }
781 }
782 
783 static int dump_info(void)
784 {
785         int rc = 0;
786 
787         if (info_threads)
788                 dump_threads();
789         else if (info_map)
790                 dump_map();
791         else {
792                 rc = -1;
793                 pr_err("Unknown type of information\n");
794         }
795 
796         return rc;
797 }
798 
799 typedef int (*tracepoint_handler)(struct perf_evsel *evsel,
800                                   struct perf_sample *sample);
801 
802 static int process_sample_event(struct perf_tool *tool __maybe_unused,
803                                 union perf_event *event,
804                                 struct perf_sample *sample,
805                                 struct perf_evsel *evsel,
806                                 struct machine *machine)
807 {
808         struct thread *thread = machine__findnew_thread(machine, sample->tid);
809 
810         if (thread == NULL) {
811                 pr_debug("problem processing %d event, skipping it.\n",
812                         event->header.type);
813                 return -1;
814         }
815 
816         if (evsel->handler.func != NULL) {
817                 tracepoint_handler f = evsel->handler.func;
818                 return f(evsel, sample);
819         }
820 
821         return 0;
822 }
823 
824 static const struct perf_evsel_str_handler lock_tracepoints[] = {
825         { "lock:lock_acquire",   perf_evsel__process_lock_acquire,   }, /* CONFIG_LOCKDEP */
826         { "lock:lock_acquired",  perf_evsel__process_lock_acquired,  }, /* CONFIG_LOCKDEP, CONFIG_LOCK_STAT */
827         { "lock:lock_contended", perf_evsel__process_lock_contended, }, /* CONFIG_LOCKDEP, CONFIG_LOCK_STAT */
828         { "lock:lock_release",   perf_evsel__process_lock_release,   }, /* CONFIG_LOCKDEP */
829 };
830 
831 static int read_events(void)
832 {
833         struct perf_tool eops = {
834                 .sample          = process_sample_event,
835                 .comm            = perf_event__process_comm,
836                 .ordered_samples = true,
837         };
838         session = perf_session__new(input_name, O_RDONLY, 0, false, &eops);
839         if (!session) {
840                 pr_err("Initializing perf session failed\n");
841                 return -1;
842         }
843 
844         if (perf_session__set_tracepoints_handlers(session, lock_tracepoints)) {
845                 pr_err("Initializing perf session tracepoint handlers failed\n");
846                 return -1;
847         }
848 
849         return perf_session__process_events(session, &eops);
850 }
851 
852 static void sort_result(void)
853 {
854         unsigned int i;
855         struct lock_stat *st;
856 
857         for (i = 0; i < LOCKHASH_SIZE; i++) {
858                 list_for_each_entry(st, &lockhash_table[i], hash_entry) {
859                         insert_to_result(st, compare);
860                 }
861         }
862 }
863 
864 static int __cmd_report(void)
865 {
866         setup_pager();
867 
868         if ((select_key() != 0) ||
869             (read_events() != 0))
870                 return -1;
871 
872         sort_result();
873         print_result();
874 
875         return 0;
876 }
877 
878 static int __cmd_record(int argc, const char **argv)
879 {
880         const char *record_args[] = {
881                 "record", "-R", "-f", "-m", "1024", "-c", "1",
882         };
883         unsigned int rec_argc, i, j;
884         const char **rec_argv;
885 
886         for (i = 0; i < ARRAY_SIZE(lock_tracepoints); i++) {
887                 if (!is_valid_tracepoint(lock_tracepoints[i].name)) {
888                                 pr_err("tracepoint %s is not enabled. "
889                                        "Are CONFIG_LOCKDEP and CONFIG_LOCK_STAT enabled?\n",
890                                        lock_tracepoints[i].name);
891                                 return 1;
892                 }
893         }
894 
895         rec_argc = ARRAY_SIZE(record_args) + argc - 1;
896         /* factor of 2 is for -e in front of each tracepoint */
897         rec_argc += 2 * ARRAY_SIZE(lock_tracepoints);
898 
899         rec_argv = calloc(rec_argc + 1, sizeof(char *));
900         if (rec_argv == NULL)
901                 return -ENOMEM;
902 
903         for (i = 0; i < ARRAY_SIZE(record_args); i++)
904                 rec_argv[i] = strdup(record_args[i]);
905 
906         for (j = 0; j < ARRAY_SIZE(lock_tracepoints); j++) {
907                 rec_argv[i++] = "-e";
908                 rec_argv[i++] = strdup(lock_tracepoints[j].name);
909         }
910 
911         for (j = 1; j < (unsigned int)argc; j++, i++)
912                 rec_argv[i] = argv[j];
913 
914         BUG_ON(i != rec_argc);
915 
916         return cmd_record(i, rec_argv, NULL);
917 }
918 
919 int cmd_lock(int argc, const char **argv, const char *prefix __maybe_unused)
920 {
921         const struct option info_options[] = {
922         OPT_BOOLEAN('t', "threads", &info_threads,
923                     "dump thread list in perf.data"),
924         OPT_BOOLEAN('m', "map", &info_map,
925                     "map of lock instances (address:name table)"),
926         OPT_END()
927         };
928         const struct option lock_options[] = {
929         OPT_STRING('i', "input", &input_name, "file", "input file name"),
930         OPT_INCR('v', "verbose", &verbose, "be more verbose (show symbol address, etc)"),
931         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, "dump raw trace in ASCII"),
932         OPT_END()
933         };
934         const struct option report_options[] = {
935         OPT_STRING('k', "key", &sort_key, "acquired",
936                     "key for sorting (acquired / contended / wait_total / wait_max / wait_min)"),
937         /* TODO: type */
938         OPT_END()
939         };
940         const char * const info_usage[] = {
941                 "perf lock info [<options>]",
942                 NULL
943         };
944         const char * const lock_usage[] = {
945                 "perf lock [<options>] {record|report|script|info}",
946                 NULL
947         };
948         const char * const report_usage[] = {
949                 "perf lock report [<options>]",
950                 NULL
951         };
952         unsigned int i;
953         int rc = 0;
954 
955         symbol__init();
956         for (i = 0; i < LOCKHASH_SIZE; i++)
957                 INIT_LIST_HEAD(lockhash_table + i);
958 
959         argc = parse_options(argc, argv, lock_options, lock_usage,
960                              PARSE_OPT_STOP_AT_NON_OPTION);
961         if (!argc)
962                 usage_with_options(lock_usage, lock_options);
963 
964         if (!strncmp(argv[0], "rec", 3)) {
965                 return __cmd_record(argc, argv);
966         } else if (!strncmp(argv[0], "report", 6)) {
967                 trace_handler = &report_lock_ops;
968                 if (argc) {
969                         argc = parse_options(argc, argv,
970                                              report_options, report_usage, 0);
971                         if (argc)
972                                 usage_with_options(report_usage, report_options);
973                 }
974                 __cmd_report();
975         } else if (!strcmp(argv[0], "script")) {
976                 /* Aliased to 'perf script' */
977                 return cmd_script(argc, argv, prefix);
978         } else if (!strcmp(argv[0], "info")) {
979                 if (argc) {
980                         argc = parse_options(argc, argv,
981                                              info_options, info_usage, 0);
982                         if (argc)
983                                 usage_with_options(info_usage, info_options);
984                 }
985                 /* recycling report_lock_ops */
986                 trace_handler = &report_lock_ops;
987                 setup_pager();
988                 if (read_events() != 0)
989                         rc = -1;
990                 else
991                         rc = dump_info();
992         } else {
993                 usage_with_options(lock_usage, lock_options);
994         }
995 
996         return rc;
997 }
998 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp