]> Git Repo - J-linux.git/blob - tools/testing/selftests/bpf/prog_tests/ksyms_btf.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / tools / testing / selftests / bpf / prog_tests / ksyms_btf.c
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2020 Google */
3
4 #include <test_progs.h>
5 #include <bpf/libbpf.h>
6 #include <bpf/btf.h>
7 #include "test_ksyms_btf.skel.h"
8 #include "test_ksyms_btf_null_check.skel.h"
9 #include "test_ksyms_weak.skel.h"
10 #include "test_ksyms_weak.lskel.h"
11 #include "test_ksyms_btf_write_check.skel.h"
12
13 static int duration;
14
15 static void test_basic(void)
16 {
17         __u64 runqueues_addr, bpf_prog_active_addr;
18         __u32 this_rq_cpu;
19         int this_bpf_prog_active;
20         struct test_ksyms_btf *skel = NULL;
21         struct test_ksyms_btf__data *data;
22         int err;
23
24         err = kallsyms_find("runqueues", &runqueues_addr);
25         if (CHECK(err == -EINVAL, "kallsyms_fopen", "failed to open: %d\n", errno))
26                 return;
27         if (CHECK(err == -ENOENT, "ksym_find", "symbol 'runqueues' not found\n"))
28                 return;
29
30         err = kallsyms_find("bpf_prog_active", &bpf_prog_active_addr);
31         if (CHECK(err == -EINVAL, "kallsyms_fopen", "failed to open: %d\n", errno))
32                 return;
33         if (CHECK(err == -ENOENT, "ksym_find", "symbol 'bpf_prog_active' not found\n"))
34                 return;
35
36         skel = test_ksyms_btf__open_and_load();
37         if (CHECK(!skel, "skel_open", "failed to open and load skeleton\n"))
38                 goto cleanup;
39
40         err = test_ksyms_btf__attach(skel);
41         if (CHECK(err, "skel_attach", "skeleton attach failed: %d\n", err))
42                 goto cleanup;
43
44         /* trigger tracepoint */
45         usleep(1);
46
47         data = skel->data;
48         CHECK(data->out__runqueues_addr != runqueues_addr, "runqueues_addr",
49               "got %llu, exp %llu\n",
50               (unsigned long long)data->out__runqueues_addr,
51               (unsigned long long)runqueues_addr);
52         CHECK(data->out__bpf_prog_active_addr != bpf_prog_active_addr, "bpf_prog_active_addr",
53               "got %llu, exp %llu\n",
54               (unsigned long long)data->out__bpf_prog_active_addr,
55               (unsigned long long)bpf_prog_active_addr);
56
57         CHECK(data->out__rq_cpu == -1, "rq_cpu",
58               "got %u, exp != -1\n", data->out__rq_cpu);
59         CHECK(data->out__bpf_prog_active < 0, "bpf_prog_active",
60               "got %d, exp >= 0\n", data->out__bpf_prog_active);
61         CHECK(data->out__cpu_0_rq_cpu != 0, "cpu_rq(0)->cpu",
62               "got %u, exp 0\n", data->out__cpu_0_rq_cpu);
63
64         this_rq_cpu = data->out__this_rq_cpu;
65         CHECK(this_rq_cpu != data->out__rq_cpu, "this_rq_cpu",
66               "got %u, exp %u\n", this_rq_cpu, data->out__rq_cpu);
67
68         this_bpf_prog_active = data->out__this_bpf_prog_active;
69         CHECK(this_bpf_prog_active != data->out__bpf_prog_active, "this_bpf_prog_active",
70               "got %d, exp %d\n", this_bpf_prog_active,
71               data->out__bpf_prog_active);
72
73 cleanup:
74         test_ksyms_btf__destroy(skel);
75 }
76
77 static void test_null_check(void)
78 {
79         struct test_ksyms_btf_null_check *skel;
80
81         skel = test_ksyms_btf_null_check__open_and_load();
82         CHECK(skel, "skel_open", "unexpected load of a prog missing null check\n");
83
84         test_ksyms_btf_null_check__destroy(skel);
85 }
86
87 static void test_weak_syms(void)
88 {
89         struct test_ksyms_weak *skel;
90         struct test_ksyms_weak__data *data;
91         int err;
92
93         skel = test_ksyms_weak__open_and_load();
94         if (!ASSERT_OK_PTR(skel, "test_ksyms_weak__open_and_load"))
95                 return;
96
97         err = test_ksyms_weak__attach(skel);
98         if (!ASSERT_OK(err, "test_ksyms_weak__attach"))
99                 goto cleanup;
100
101         /* trigger tracepoint */
102         usleep(1);
103
104         data = skel->data;
105         ASSERT_EQ(data->out__existing_typed, 0, "existing typed ksym");
106         ASSERT_NEQ(data->out__existing_typeless, -1, "existing typeless ksym");
107         ASSERT_EQ(data->out__non_existent_typeless, 0, "nonexistent typeless ksym");
108         ASSERT_EQ(data->out__non_existent_typed, 0, "nonexistent typed ksym");
109
110 cleanup:
111         test_ksyms_weak__destroy(skel);
112 }
113
114 static void test_weak_syms_lskel(void)
115 {
116         struct test_ksyms_weak_lskel *skel;
117         struct test_ksyms_weak_lskel__data *data;
118         int err;
119
120         skel = test_ksyms_weak_lskel__open_and_load();
121         if (!ASSERT_OK_PTR(skel, "test_ksyms_weak_lskel__open_and_load"))
122                 return;
123
124         err = test_ksyms_weak_lskel__attach(skel);
125         if (!ASSERT_OK(err, "test_ksyms_weak_lskel__attach"))
126                 goto cleanup;
127
128         /* trigger tracepoint */
129         usleep(1);
130
131         data = skel->data;
132         ASSERT_EQ(data->out__existing_typed, 0, "existing typed ksym");
133         ASSERT_NEQ(data->out__existing_typeless, -1, "existing typeless ksym");
134         ASSERT_EQ(data->out__non_existent_typeless, 0, "nonexistent typeless ksym");
135         ASSERT_EQ(data->out__non_existent_typed, 0, "nonexistent typed ksym");
136
137 cleanup:
138         test_ksyms_weak_lskel__destroy(skel);
139 }
140
141 static void test_write_check(bool test_handler1)
142 {
143         struct test_ksyms_btf_write_check *skel;
144
145         skel = test_ksyms_btf_write_check__open();
146         if (!ASSERT_OK_PTR(skel, "test_ksyms_btf_write_check__open"))
147                 return;
148         bpf_program__set_autoload(test_handler1 ? skel->progs.handler2 : skel->progs.handler1, false);
149         ASSERT_ERR(test_ksyms_btf_write_check__load(skel),
150                    "unexpected load of a prog writing to ksym memory\n");
151
152         test_ksyms_btf_write_check__destroy(skel);
153 }
154
155 void test_ksyms_btf(void)
156 {
157         int percpu_datasec;
158         struct btf *btf;
159
160         btf = libbpf_find_kernel_btf();
161         if (!ASSERT_OK_PTR(btf, "btf_exists"))
162                 return;
163
164         percpu_datasec = btf__find_by_name_kind(btf, ".data..percpu",
165                                                 BTF_KIND_DATASEC);
166         btf__free(btf);
167         if (percpu_datasec < 0) {
168                 printf("%s:SKIP:no PERCPU DATASEC in kernel btf\n",
169                        __func__);
170                 test__skip();
171                 return;
172         }
173
174         if (test__start_subtest("basic"))
175                 test_basic();
176
177         if (test__start_subtest("null_check"))
178                 test_null_check();
179
180         if (test__start_subtest("weak_ksyms"))
181                 test_weak_syms();
182
183         if (test__start_subtest("weak_ksyms_lskel"))
184                 test_weak_syms_lskel();
185
186         if (test__start_subtest("write_check1"))
187                 test_write_check(true);
188
189         if (test__start_subtest("write_check2"))
190                 test_write_check(false);
191 }
This page took 0.036886 seconds and 4 git commands to generate.