1 // SPDX-License-Identifier: GPL-2.0
2 #include "util/debug.h"
3 #include "util/evlist.h"
4 #include "util/machine.h"
5 #include "util/map.h"
6 #include "util/symbol.h"
7 #include "util/target.h"
8 #include "util/thread_map.h"
9 #include "util/lock-contention.h"
10 #include <linux/zalloc.h>
11 #include <linux/string.h>
12 #include <bpf/bpf.h>
13 
14 #include "bpf_skel/lock_contention.skel.h"
15 
16 static struct lock_contention_bpf *skel;
17 
18 struct lock_contention_data {
19 	u64 total_time;
20 	u64 min_time;
21 	u64 max_time;
22 	u32 count;
23 	u32 flags;
24 };
25 
26 int lock_contention_prepare(struct lock_contention *con)
27 {
28 	int i, fd;
29 	int ncpus = 1, ntasks = 1;
30 	struct evlist *evlist = con->evlist;
31 	struct target *target = con->target;
32 
33 	skel = lock_contention_bpf__open();
34 	if (!skel) {
35 		pr_err("Failed to open lock-contention BPF skeleton\n");
36 		return -1;
37 	}
38 
39 	bpf_map__set_value_size(skel->maps.stacks, con->max_stack * sizeof(u64));
40 	bpf_map__set_max_entries(skel->maps.stacks, con->map_nr_entries);
41 	bpf_map__set_max_entries(skel->maps.lock_stat, con->map_nr_entries);
42 
43 	if (target__has_cpu(target))
44 		ncpus = perf_cpu_map__nr(evlist->core.user_requested_cpus);
45 	if (target__has_task(target))
46 		ntasks = perf_thread_map__nr(evlist->core.threads);
47 
48 	bpf_map__set_max_entries(skel->maps.cpu_filter, ncpus);
49 	bpf_map__set_max_entries(skel->maps.task_filter, ntasks);
50 
51 	if (lock_contention_bpf__load(skel) < 0) {
52 		pr_err("Failed to load lock-contention BPF skeleton\n");
53 		return -1;
54 	}
55 
56 	if (target__has_cpu(target)) {
57 		u32 cpu;
58 		u8 val = 1;
59 
60 		skel->bss->has_cpu = 1;
61 		fd = bpf_map__fd(skel->maps.cpu_filter);
62 
63 		for (i = 0; i < ncpus; i++) {
64 			cpu = perf_cpu_map__cpu(evlist->core.user_requested_cpus, i).cpu;
65 			bpf_map_update_elem(fd, &cpu, &val, BPF_ANY);
66 		}
67 	}
68 
69 	if (target__has_task(target)) {
70 		u32 pid;
71 		u8 val = 1;
72 
73 		skel->bss->has_task = 1;
74 		fd = bpf_map__fd(skel->maps.task_filter);
75 
76 		for (i = 0; i < ntasks; i++) {
77 			pid = perf_thread_map__pid(evlist->core.threads, i);
78 			bpf_map_update_elem(fd, &pid, &val, BPF_ANY);
79 		}
80 	}
81 
82 	if (target__none(target) && evlist->workload.pid > 0) {
83 		u32 pid = evlist->workload.pid;
84 		u8 val = 1;
85 
86 		skel->bss->has_task = 1;
87 		fd = bpf_map__fd(skel->maps.task_filter);
88 		bpf_map_update_elem(fd, &pid, &val, BPF_ANY);
89 	}
90 
91 	skel->bss->stack_skip = con->stack_skip;
92 
93 	lock_contention_bpf__attach(skel);
94 	return 0;
95 }
96 
97 int lock_contention_start(void)
98 {
99 	skel->bss->enabled = 1;
100 	return 0;
101 }
102 
103 int lock_contention_stop(void)
104 {
105 	skel->bss->enabled = 0;
106 	return 0;
107 }
108 
109 int lock_contention_read(struct lock_contention *con)
110 {
111 	int fd, stack;
112 	s32 prev_key, key;
113 	struct lock_contention_data data;
114 	struct lock_stat *st;
115 	struct machine *machine = con->machine;
116 	u64 stack_trace[con->max_stack];
117 
118 	fd = bpf_map__fd(skel->maps.lock_stat);
119 	stack = bpf_map__fd(skel->maps.stacks);
120 
121 	con->lost = skel->bss->lost;
122 
123 	prev_key = 0;
124 	while (!bpf_map_get_next_key(fd, &prev_key, &key)) {
125 		struct map *kmap;
126 		struct symbol *sym;
127 		int idx = 0;
128 
129 		bpf_map_lookup_elem(fd, &key, &data);
130 		st = zalloc(sizeof(*st));
131 		if (st == NULL)
132 			return -1;
133 
134 		st->nr_contended = data.count;
135 		st->wait_time_total = data.total_time;
136 		st->wait_time_max = data.max_time;
137 		st->wait_time_min = data.min_time;
138 
139 		if (data.count)
140 			st->avg_wait_time = data.total_time / data.count;
141 
142 		st->flags = data.flags;
143 
144 		bpf_map_lookup_elem(stack, &key, stack_trace);
145 
146 		/* skip lock internal functions */
147 		while (is_lock_function(machine, stack_trace[idx]) &&
148 		       idx < con->max_stack - 1)
149 			idx++;
150 
151 		st->addr = stack_trace[idx];
152 		sym = machine__find_kernel_symbol(machine, st->addr, &kmap);
153 
154 		if (sym) {
155 			unsigned long offset;
156 			int ret = 0;
157 
158 			offset = kmap->map_ip(kmap, st->addr) - sym->start;
159 
160 			if (offset)
161 				ret = asprintf(&st->name, "%s+%#lx", sym->name, offset);
162 			else
163 				st->name = strdup(sym->name);
164 
165 			if (ret < 0 || st->name == NULL)
166 				return -1;
167 		} else if (asprintf(&st->name, "%#lx", (unsigned long)st->addr) < 0) {
168 			free(st);
169 			return -1;
170 		}
171 
172 		if (verbose) {
173 			st->callstack = memdup(stack_trace, sizeof(stack_trace));
174 			if (st->callstack == NULL) {
175 				free(st);
176 				return -1;
177 			}
178 		}
179 
180 		hlist_add_head(&st->hash_entry, con->result);
181 		prev_key = key;
182 	}
183 
184 	return 0;
185 }
186 
187 int lock_contention_finish(void)
188 {
189 	if (skel) {
190 		skel->bss->enabled = 0;
191 		lock_contention_bpf__destroy(skel);
192 	}
193 
194 	return 0;
195 }
196