test_task_work.c

  1// SPDX-License-Identifier: GPL-2.0
  2/* Copyright (c) 2025 Meta Platforms, Inc. and affiliates. */
  3#include <test_progs.h>
  4#include <string.h>
  5#include <stdio.h>
  6#include "task_work.skel.h"
  7#include "task_work_fail.skel.h"
  8#include <linux/bpf.h>
  9#include <linux/perf_event.h>
 10#include <sys/syscall.h>
 11#include <time.h>
 12
 13static int perf_event_open(__u32 type, __u64 config, int pid)
 14{
 15	struct perf_event_attr attr = {
 16		.type = type,
 17		.config = config,
 18		.size = sizeof(struct perf_event_attr),
 19		.sample_period = 100000,
 20	};
 21
 22	return syscall(__NR_perf_event_open, &attr, pid, -1, -1, 0);
 23}
 24
 25struct elem {
 26	char data[128];
 27	struct bpf_task_work tw;
 28};
 29
 30static int verify_map(struct bpf_map *map, const char *expected_data)
 31{
 32	int err;
 33	struct elem value;
 34	int processed_values = 0;
 35	int k, sz;
 36
 37	sz = bpf_map__max_entries(map);
 38	for (k = 0; k < sz; ++k) {
 39		err = bpf_map__lookup_elem(map, &k, sizeof(int), &value, sizeof(struct elem), 0);
 40		if (err)
 41			continue;
 42		if (!ASSERT_EQ(strcmp(expected_data, value.data), 0, "map data")) {
 43			fprintf(stderr, "expected '%s', found '%s' in %s map", expected_data,
 44				value.data, bpf_map__name(map));
 45			return 2;
 46		}
 47		processed_values++;
 48	}
 49
 50	return processed_values == 0;
 51}
 52
 53static void task_work_run(const char *prog_name, const char *map_name)
 54{
 55	struct task_work *skel;
 56	struct bpf_program *prog;
 57	struct bpf_map *map;
 58	struct bpf_link *link = NULL;
 59	int err, pe_fd = -1, pid, status, pipefd[2];
 60	char user_string[] = "hello world";
 61
 62	if (!ASSERT_NEQ(pipe(pipefd), -1, "pipe"))
 63		return;
 64
 65	pid = fork();
 66	if (pid == 0) {
 67		__u64 num = 1;
 68		int i;
 69		char buf;
 70
 71		close(pipefd[1]);
 72		read(pipefd[0], &buf, sizeof(buf));
 73		close(pipefd[0]);
 74
 75		for (i = 0; i < 10000; ++i)
 76			num *= time(0) % 7;
 77		(void)num;
 78		exit(0);
 79	}
 80	if (!ASSERT_GT(pid, 0, "fork() failed")) {
 81		close(pipefd[0]);
 82		close(pipefd[1]);
 83		return;
 84	}
 85
 86	skel = task_work__open();
 87	if (!ASSERT_OK_PTR(skel, "task_work__open"))
 88		return;
 89
 90	bpf_object__for_each_program(prog, skel->obj) {
 91		bpf_program__set_autoload(prog, false);
 92	}
 93
 94	prog = bpf_object__find_program_by_name(skel->obj, prog_name);
 95	if (!ASSERT_OK_PTR(prog, "prog_name"))
 96		goto cleanup;
 97	bpf_program__set_autoload(prog, true);
 98	skel->bss->user_ptr = (char *)user_string;
 99
100	err = task_work__load(skel);
101	if (!ASSERT_OK(err, "skel_load"))
102		goto cleanup;
103
104	pe_fd = perf_event_open(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES, pid);
105	if (pe_fd == -1 && (errno == ENOENT || errno == EOPNOTSUPP)) {
106		printf("%s:SKIP:no PERF_COUNT_HW_CPU_CYCLES\n", __func__);
107		test__skip();
108		goto cleanup;
109	}
110	if (!ASSERT_NEQ(pe_fd, -1, "pe_fd")) {
111		fprintf(stderr, "perf_event_open errno: %d, pid: %d\n", errno, pid);
112		goto cleanup;
113	}
114
115	link = bpf_program__attach_perf_event(prog, pe_fd);
116	if (!ASSERT_OK_PTR(link, "attach_perf_event"))
117		goto cleanup;
118
119	/* perf event fd ownership is passed to bpf_link */
120	pe_fd = -1;
121	close(pipefd[0]);
122	write(pipefd[1], user_string, 1);
123	close(pipefd[1]);
124	/* Wait to collect some samples */
125	waitpid(pid, &status, 0);
126	pid = 0;
127	map = bpf_object__find_map_by_name(skel->obj, map_name);
128	if (!ASSERT_OK_PTR(map, "find map_name"))
129		goto cleanup;
130	if (!ASSERT_OK(verify_map(map, user_string), "verify map"))
131		goto cleanup;
132cleanup:
133	if (pe_fd >= 0)
134		close(pe_fd);
135	bpf_link__destroy(link);
136	task_work__destroy(skel);
137	if (pid > 0) {
138		close(pipefd[0]);
139		write(pipefd[1], user_string, 1);
140		close(pipefd[1]);
141		waitpid(pid, &status, 0);
142	}
143}
144
145void test_task_work(void)
146{
147	if (test__start_subtest("test_task_work_hash_map"))
148		task_work_run("oncpu_hash_map", "hmap");
149
150	if (test__start_subtest("test_task_work_array_map"))
151		task_work_run("oncpu_array_map", "arrmap");
152
153	if (test__start_subtest("test_task_work_lru_map"))
154		task_work_run("oncpu_lru_map", "lrumap");
155
156	RUN_TESTS(task_work_fail);
157}