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