1 // SPDX-License-Identifier: GPL-2.0 2 #ifndef PERF_LOCK_CONTENTION_H 3 #define PERF_LOCK_CONTENTION_H 4 5 #include <linux/list.h> 6 #include <linux/rbtree.h> 7 8 struct lock_filter { 9 int nr_types; 10 int nr_addrs; 11 int nr_syms; 12 unsigned int *types; 13 unsigned long *addrs; 14 char **syms; 15 }; 16 17 struct lock_stat { 18 struct hlist_node hash_entry; 19 struct rb_node rb; /* used for sorting */ 20 21 u64 addr; /* address of lockdep_map, used as ID */ 22 char *name; /* for strcpy(), we cannot use const */ 23 u64 *callstack; 24 25 unsigned int nr_acquire; 26 unsigned int nr_acquired; 27 unsigned int nr_contended; 28 unsigned int nr_release; 29 30 union { 31 unsigned int nr_readlock; 32 unsigned int flags; 33 }; 34 unsigned int nr_trylock; 35 36 /* these times are in nano sec. */ 37 u64 avg_wait_time; 38 u64 wait_time_total; 39 u64 wait_time_min; 40 u64 wait_time_max; 41 42 int broken; /* flag of blacklist */ 43 int combined; 44 }; 45 46 /* 47 * States of lock_seq_stat 48 * 49 * UNINITIALIZED is required for detecting first event of acquire. 50 * As the nature of lock events, there is no guarantee 51 * that the first event for the locks are acquire, 52 * it can be acquired, contended or release. 53 */ 54 #define SEQ_STATE_UNINITIALIZED 0 /* initial state */ 55 #define SEQ_STATE_RELEASED 1 56 #define SEQ_STATE_ACQUIRING 2 57 #define SEQ_STATE_ACQUIRED 3 58 #define SEQ_STATE_READ_ACQUIRED 4 59 #define SEQ_STATE_CONTENDED 5 60 61 /* 62 * MAX_LOCK_DEPTH 63 * Imported from include/linux/sched.h. 64 * Should this be synchronized? 65 */ 66 #define MAX_LOCK_DEPTH 48 67 68 struct lock_stat *lock_stat_find(u64 addr); 69 struct lock_stat *lock_stat_findnew(u64 addr, const char *name, int flags); 70 71 bool match_callstack_filter(struct machine *machine, u64 *callstack); 72 73 /* 74 * struct lock_seq_stat: 75 * Place to put on state of one lock sequence 76 * 1) acquire -> acquired -> release 77 * 2) acquire -> contended -> acquired -> release 78 * 3) acquire (with read or try) -> release 79 * 4) Are there other patterns? 80 */ 81 struct lock_seq_stat { 82 struct list_head list; 83 int state; 84 u64 prev_event_time; 85 u64 addr; 86 87 int read_count; 88 }; 89 90 struct thread_stat { 91 struct rb_node rb; 92 93 u32 tid; 94 struct list_head seq_list; 95 }; 96 97 /* 98 * CONTENTION_STACK_DEPTH 99 * Number of stack trace entries to find callers 100 */ 101 #define CONTENTION_STACK_DEPTH 8 102 103 /* 104 * CONTENTION_STACK_SKIP 105 * Number of stack trace entries to skip when finding callers. 106 * The first few entries belong to the locking implementation itself. 107 */ 108 #define CONTENTION_STACK_SKIP 4 109 110 /* 111 * flags for lock:contention_begin 112 * Imported from include/trace/events/lock.h. 113 */ 114 #define LCB_F_SPIN (1U << 0) 115 #define LCB_F_READ (1U << 1) 116 #define LCB_F_WRITE (1U << 2) 117 #define LCB_F_RT (1U << 3) 118 #define LCB_F_PERCPU (1U << 4) 119 #define LCB_F_MUTEX (1U << 5) 120 121 struct evlist; 122 struct machine; 123 struct target; 124 125 struct lock_contention_fails { 126 int task; 127 int stack; 128 int time; 129 int data; 130 }; 131 132 struct lock_contention { 133 struct evlist *evlist; 134 struct target *target; 135 struct machine *machine; 136 struct hlist_head *result; 137 struct lock_filter *filters; 138 struct lock_contention_fails fails; 139 unsigned long map_nr_entries; 140 int max_stack; 141 int stack_skip; 142 int aggr_mode; 143 int owner; 144 int nr_filtered; 145 bool save_callstack; 146 }; 147 148 #ifdef HAVE_BPF_SKEL 149 150 int lock_contention_prepare(struct lock_contention *con); 151 int lock_contention_start(void); 152 int lock_contention_stop(void); 153 int lock_contention_read(struct lock_contention *con); 154 int lock_contention_finish(void); 155 156 #else /* !HAVE_BPF_SKEL */ 157 lock_contention_prepare(struct lock_contention * con __maybe_unused)158static inline int lock_contention_prepare(struct lock_contention *con __maybe_unused) 159 { 160 return 0; 161 } 162 lock_contention_start(void)163static inline int lock_contention_start(void) { return 0; } lock_contention_stop(void)164static inline int lock_contention_stop(void) { return 0; } lock_contention_finish(void)165static inline int lock_contention_finish(void) { return 0; } 166 lock_contention_read(struct lock_contention * con __maybe_unused)167static inline int lock_contention_read(struct lock_contention *con __maybe_unused) 168 { 169 return 0; 170 } 171 172 #endif /* HAVE_BPF_SKEL */ 173 174 #endif /* PERF_LOCK_CONTENTION_H */ 175