1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * bpf_kwork_top.c
  4 *
  5 * Copyright (c) 2022  Huawei Inc,  Yang Jihong <yangjihong1@huawei.com>
  6 */
  7
  8#include <time.h>
  9#include <fcntl.h>
 10#include <signal.h>
 11#include <stdio.h>
 12#include <unistd.h>
 13
 14#include <linux/time64.h>
 15
 16#include "util/debug.h"
 17#include "util/evsel.h"
 18#include "util/kwork.h"
 19
 20#include <bpf/bpf.h>
 21#include <perf/cpumap.h>
 22
 23#include "util/bpf_skel/kwork_top.skel.h"
 24
 25/*
 26 * This should be in sync with "util/kwork_top.bpf.c"
 27 */
 28#define MAX_COMMAND_LEN 16
 29
 30struct time_data {
 31	__u64 timestamp;
 32};
 33
 34struct work_data {
 35	__u64 runtime;
 36};
 37
 38struct task_data {
 39	__u32 tgid;
 40	__u32 is_kthread;
 41	char comm[MAX_COMMAND_LEN];
 42};
 43
 44struct work_key {
 45	__u32 type;
 46	__u32 pid;
 47	__u64 task_p;
 48};
 49
 50struct task_key {
 51	__u32 pid;
 52	__u32 cpu;
 53};
 54
 55struct kwork_class_bpf {
 56	struct kwork_class *class;
 57	void (*load_prepare)(void);
 58};
 59
 60static struct kwork_top_bpf *skel;
 61
 62void perf_kwork__top_start(void)
 63{
 64	struct timespec ts;
 65
 66	clock_gettime(CLOCK_MONOTONIC, &ts);
 67	skel->bss->from_timestamp = (u64)ts.tv_sec * NSEC_PER_SEC + ts.tv_nsec;
 68	skel->bss->enabled = 1;
 69	pr_debug("perf kwork top start at: %lld\n", skel->bss->from_timestamp);
 70}
 71
 72void perf_kwork__top_finish(void)
 73{
 74	struct timespec ts;
 75
 76	skel->bss->enabled = 0;
 77	clock_gettime(CLOCK_MONOTONIC, &ts);
 78	skel->bss->to_timestamp = (u64)ts.tv_sec * NSEC_PER_SEC + ts.tv_nsec;
 79	pr_debug("perf kwork top finish at: %lld\n", skel->bss->to_timestamp);
 80}
 81
 82static void irq_load_prepare(void)
 83{
 84	bpf_program__set_autoload(skel->progs.on_irq_handler_entry, true);
 85	bpf_program__set_autoload(skel->progs.on_irq_handler_exit, true);
 86}
 87
 88static struct kwork_class_bpf kwork_irq_bpf = {
 89	.load_prepare = irq_load_prepare,
 90};
 91
 92static void softirq_load_prepare(void)
 93{
 94	bpf_program__set_autoload(skel->progs.on_softirq_entry, true);
 95	bpf_program__set_autoload(skel->progs.on_softirq_exit, true);
 96}
 97
 98static struct kwork_class_bpf kwork_softirq_bpf = {
 99	.load_prepare = softirq_load_prepare,
100};
101
102static void sched_load_prepare(void)
103{
104	bpf_program__set_autoload(skel->progs.on_switch, true);
105}
106
107static struct kwork_class_bpf kwork_sched_bpf = {
108	.load_prepare = sched_load_prepare,
109};
110
111static struct kwork_class_bpf *
112kwork_class_bpf_supported_list[KWORK_CLASS_MAX] = {
113	[KWORK_CLASS_IRQ]	= &kwork_irq_bpf,
114	[KWORK_CLASS_SOFTIRQ]	= &kwork_softirq_bpf,
115	[KWORK_CLASS_SCHED]	= &kwork_sched_bpf,
116};
117
118static bool valid_kwork_class_type(enum kwork_class_type type)
119{
120	return type >= 0 && type < KWORK_CLASS_MAX;
121}
122
123static int setup_filters(struct perf_kwork *kwork)
124{
125	u8 val = 1;
126	int i, nr_cpus, fd;
127	struct perf_cpu_map *map;
128
129	if (kwork->cpu_list) {
130		fd = bpf_map__fd(skel->maps.kwork_top_cpu_filter);
131		if (fd < 0) {
132			pr_debug("Invalid cpu filter fd\n");
133			return -1;
134		}
135
136		map = perf_cpu_map__new(kwork->cpu_list);
137		if (!map) {
138			pr_debug("Invalid cpu_list\n");
139			return -1;
140		}
141
142		nr_cpus = libbpf_num_possible_cpus();
143		for (i = 0; i < perf_cpu_map__nr(map); i++) {
144			struct perf_cpu cpu = perf_cpu_map__cpu(map, i);
145
146			if (cpu.cpu >= nr_cpus) {
147				perf_cpu_map__put(map);
148				pr_err("Requested cpu %d too large\n", cpu.cpu);
149				return -1;
150			}
151			bpf_map_update_elem(fd, &cpu.cpu, &val, BPF_ANY);
152		}
153		perf_cpu_map__put(map);
154
155		skel->bss->has_cpu_filter = 1;
156	}
157
158	return 0;
159}
160
161int perf_kwork__top_prepare_bpf(struct perf_kwork *kwork __maybe_unused)
162{
163	struct bpf_program *prog;
164	struct kwork_class *class;
165	struct kwork_class_bpf *class_bpf;
166	enum kwork_class_type type;
167
168	skel = kwork_top_bpf__open();
169	if (!skel) {
170		pr_debug("Failed to open kwork top skeleton\n");
171		return -1;
172	}
173
174	/*
175	 * set all progs to non-autoload,
176	 * then set corresponding progs according to config
177	 */
178	bpf_object__for_each_program(prog, skel->obj)
179		bpf_program__set_autoload(prog, false);
180
181	list_for_each_entry(class, &kwork->class_list, list) {
182		type = class->type;
183		if (!valid_kwork_class_type(type) ||
184		    !kwork_class_bpf_supported_list[type]) {
185			pr_err("Unsupported bpf trace class %s\n", class->name);
186			goto out;
187		}
188
189		class_bpf = kwork_class_bpf_supported_list[type];
190		class_bpf->class = class;
191
192		if (class_bpf->load_prepare)
193			class_bpf->load_prepare();
194	}
195
196	if (kwork_top_bpf__load(skel)) {
197		pr_debug("Failed to load kwork top skeleton\n");
198		goto out;
199	}
200
201	if (setup_filters(kwork))
202		goto out;
203
204	if (kwork_top_bpf__attach(skel)) {
205		pr_debug("Failed to attach kwork top skeleton\n");
206		goto out;
207	}
208
209	return 0;
210
211out:
212	kwork_top_bpf__destroy(skel);
213	return -1;
214}
215
216static void read_task_info(struct kwork_work *work)
217{
218	int fd;
219	struct task_data data;
220	struct task_key key = {
221		.pid = work->id,
222		.cpu = work->cpu,
223	};
224
225	fd = bpf_map__fd(skel->maps.kwork_top_tasks);
226	if (fd < 0) {
227		pr_debug("Invalid top tasks map fd\n");
228		return;
229	}
230
231	if (!bpf_map_lookup_elem(fd, &key, &data)) {
232		work->tgid = data.tgid;
233		work->is_kthread = data.is_kthread;
234		work->name = strdup(data.comm);
235	}
236}
237static int add_work(struct perf_kwork *kwork, struct work_key *key,
238		    struct work_data *data, int cpu)
239{
240	struct kwork_class_bpf *bpf_trace;
241	struct kwork_work *work;
242	struct kwork_work tmp = {
243		.id = key->pid,
244		.cpu = cpu,
245		.name = NULL,
246	};
247	enum kwork_class_type type = key->type;
248
249	if (!valid_kwork_class_type(type)) {
250		pr_debug("Invalid class type %d to add work\n", type);
251		return -1;
252	}
253
254	bpf_trace = kwork_class_bpf_supported_list[type];
255	tmp.class = bpf_trace->class;
256
257	work = perf_kwork_add_work(kwork, tmp.class, &tmp);
258	if (!work)
259		return -1;
260
261	work->total_runtime = data->runtime;
262	read_task_info(work);
263
264	return 0;
265}
266
267int perf_kwork__top_read_bpf(struct perf_kwork *kwork)
268{
269	int i, fd, nr_cpus;
270	struct work_data *data;
271	struct work_key key, prev;
272
273	fd = bpf_map__fd(skel->maps.kwork_top_works);
274	if (fd < 0) {
275		pr_debug("Invalid top runtime fd\n");
276		return -1;
277	}
278
279	nr_cpus = libbpf_num_possible_cpus();
280	data = calloc(nr_cpus, sizeof(struct work_data));
281	if (!data)
282		return -1;
283
284	memset(&prev, 0, sizeof(prev));
285	while (!bpf_map_get_next_key(fd, &prev, &key)) {
286		if ((bpf_map_lookup_elem(fd, &key, data)) != 0) {
287			pr_debug("Failed to lookup top elem\n");
288			return -1;
289		}
290
291		for (i = 0; i < nr_cpus; i++) {
292			if (data[i].runtime == 0)
293				continue;
294
295			if (add_work(kwork, &key, &data[i], i))
296				return -1;
297		}
298		prev = key;
299	}
300	free(data);
301
302	return 0;
303}
304
305void perf_kwork__top_cleanup_bpf(void)
306{
307	kwork_top_bpf__destroy(skel);
308}