From: Alexei Starovoitov <ast@xxxxxxxxxx>
Add bpf_timer test that creates two timers. One in hash map and another global
timer in bss. It let global timer expire once and then re-arms it for 35
seconds. Then arms and re-arms hash timer 10 times and at the last invocation
cancels global timer.
Signed-off-by: Alexei Starovoitov <ast@xxxxxxxxxx>
---
.../testing/selftests/bpf/prog_tests/timer.c | 47 ++++++++++
tools/testing/selftests/bpf/progs/timer.c | 85 +++++++++++++++++++
2 files changed, 132 insertions(+)
create mode 100644 tools/testing/selftests/bpf/prog_tests/timer.c
create mode 100644 tools/testing/selftests/bpf/progs/timer.c
diff --git a/tools/testing/selftests/bpf/prog_tests/timer.c b/tools/testing/selftests/bpf/prog_tests/timer.c
new file mode 100644
index 000000000000..7be2aeba2dad
--- /dev/null
+++ b/tools/testing/selftests/bpf/prog_tests/timer.c
@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2021 Facebook */
+#include <test_progs.h>
+#include "timer.skel.h"
+
+static int timer(struct timer *timer_skel)
+{
+ int err, prog_fd;
+ __u32 duration = 0, retval;
+
+ err = timer__attach(timer_skel);
+ if (!ASSERT_OK(err, "timer_attach"))
+ return err;
+
+ ASSERT_EQ(timer_skel->data->callback_check, 52, "callback_check1");
+
+ prog_fd = bpf_program__fd(timer_skel->progs.test1);
+ err = bpf_prog_test_run(prog_fd, 1, NULL, 0,
+ NULL, NULL, &retval, &duration);
+ ASSERT_OK(err, "test_run");
+ ASSERT_EQ(retval, 0, "test_run");
+ timer__detach(timer_skel);
+
+ usleep(50 * 1000); /* 10 msecs should be enough, but give it extra */
+ /* check that timer_cb1() was executed 10 times */
+ ASSERT_EQ(timer_skel->data->callback_check, 42, "callback_check2");
+
+ /* check that timer_cb2() was executed once */
+ ASSERT_EQ(timer_skel->bss->bss_data, 15, "bss_data");
+
+ return 0;
+}
+
+void test_timer(void)
+{
+ struct timer *timer_skel = NULL;
+ int err;
+
+ timer_skel = timer__open_and_load();
+ if (!ASSERT_OK_PTR(timer_skel, "timer_skel_load"))
+ goto cleanup;
+
+ err = timer(timer_skel);
+ ASSERT_OK(err, "timer");
+cleanup:
+ timer__destroy(timer_skel);
+}
diff --git a/tools/testing/selftests/bpf/progs/timer.c b/tools/testing/selftests/bpf/progs/timer.c
new file mode 100644
index 000000000000..d20672cf61d6
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/timer.c
@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2021 Facebook */
+#include <linux/bpf.h>
+#include <bpf/bpf_helpers.h>
+#include "bpf_tcp_helpers.h"
+
+char _license[] SEC("license") = "GPL";
+struct map_elem {
+ int counter;
+ struct bpf_timer timer;
+};
+
+struct {
+ __uint(type, BPF_MAP_TYPE_HASH);
+ __uint(max_entries, 1000);
+ __type(key, int);
+ __type(value, struct map_elem);
+} hmap SEC(".maps");
+
+__u64 bss_data;
+struct bpf_timer global_timer;
+
+__u64 callback_check = 52;
+
+static int timer_cb1(void *map, int *key, __u64 *data)
+{
+ /* increment the same bss variable twice */
+ bss_data += 5;
+ data[0] += 10; /* &data[1] == &bss_data */
+ /* note data[1] access will be rejected by the verifier,
+ * since &data[1] points to the &global_timer.
+ */
+
+ /* rearm self to be called again in ~35 seconds */
+ bpf_timer_start(&global_timer, 1ull << 35);
+ return 0;
+}
+
+SEC("fentry/bpf_fentry_test1")
+int BPF_PROG(test1, int a)
+{
+ bpf_timer_init(&global_timer, timer_cb1, 0);
+ bpf_timer_start(&global_timer, 0 /* call timer_cb1 asap */);
+ return 0;
+}
+
+static int timer_cb2(void *map, int *key, struct map_elem *val)
+{
+ callback_check--;
+ if (--val->counter)
+ /* re-arm the timer again to execute after 1 msec */
+ bpf_timer_start(&val->timer, 1000);
+ else {
+ /* cancel global_timer otherwise bpf_fentry_test1 prog
+ * will stay alive forever.
+ */
+ bpf_timer_cancel(&global_timer);
+ bpf_timer_cancel(&val->timer);
+ }
+ return 0;
+}
+
+int bpf_timer_test(void)
+{
+ struct map_elem *val;
+ int key = 0;
+
+ val = bpf_map_lookup_elem(&hmap, &key);
+ if (val) {
+ bpf_timer_init(&val->timer, timer_cb2, 0);
+ bpf_timer_start(&val->timer, 1000);
+ }
+ return 0;
+}
+
+SEC("fentry/bpf_fentry_test2")
+int BPF_PROG(test2, int a, int b)
+{
+ struct map_elem val = {};
+ int key = 0;
+
+ val.counter = 10; /* number of times to trigger timer_cb1 */
+ bpf_map_update_elem(&hmap, &key, &val, 0);
+ return bpf_timer_test();
+}
--
2.30.2
