1 // SPDX-License-Identifier: GPL-2.0-only
2
3 #include <test_progs.h>
4 #include "test_lookup_and_delete.skel.h"
5
6 #define START_VALUE 1234
7 #define NEW_VALUE 4321
8 #define MAX_ENTRIES 2
9
10 static int duration;
11 static int nr_cpus;
12
fill_values(int map_fd)13 static int fill_values(int map_fd)
14 {
15 __u64 key, value = START_VALUE;
16 int err;
17
18 for (key = 1; key < MAX_ENTRIES + 1; key++) {
19 err = bpf_map_update_elem(map_fd, &key, &value, BPF_NOEXIST);
20 if (!ASSERT_OK(err, "bpf_map_update_elem"))
21 return -1;
22 }
23
24 return 0;
25 }
26
fill_values_percpu(int map_fd)27 static int fill_values_percpu(int map_fd)
28 {
29 __u64 key, value[nr_cpus];
30 int i, err;
31
32 for (i = 0; i < nr_cpus; i++)
33 value[i] = START_VALUE;
34
35 for (key = 1; key < MAX_ENTRIES + 1; key++) {
36 err = bpf_map_update_elem(map_fd, &key, value, BPF_NOEXIST);
37 if (!ASSERT_OK(err, "bpf_map_update_elem"))
38 return -1;
39 }
40
41 return 0;
42 }
43
setup_prog(enum bpf_map_type map_type,int * map_fd)44 static struct test_lookup_and_delete *setup_prog(enum bpf_map_type map_type,
45 int *map_fd)
46 {
47 struct test_lookup_and_delete *skel;
48 int err;
49
50 skel = test_lookup_and_delete__open();
51 if (!ASSERT_OK_PTR(skel, "test_lookup_and_delete__open"))
52 return NULL;
53
54 err = bpf_map__set_type(skel->maps.hash_map, map_type);
55 if (!ASSERT_OK(err, "bpf_map__set_type"))
56 goto cleanup;
57
58 err = bpf_map__set_max_entries(skel->maps.hash_map, MAX_ENTRIES);
59 if (!ASSERT_OK(err, "bpf_map__set_max_entries"))
60 goto cleanup;
61
62 err = test_lookup_and_delete__load(skel);
63 if (!ASSERT_OK(err, "test_lookup_and_delete__load"))
64 goto cleanup;
65
66 *map_fd = bpf_map__fd(skel->maps.hash_map);
67 if (!ASSERT_GE(*map_fd, 0, "bpf_map__fd"))
68 goto cleanup;
69
70 return skel;
71
72 cleanup:
73 test_lookup_and_delete__destroy(skel);
74 return NULL;
75 }
76
77 /* Triggers BPF program that updates map with given key and value */
trigger_tp(struct test_lookup_and_delete * skel,__u64 key,__u64 value)78 static int trigger_tp(struct test_lookup_and_delete *skel, __u64 key,
79 __u64 value)
80 {
81 int err;
82
83 skel->bss->set_pid = getpid();
84 skel->bss->set_key = key;
85 skel->bss->set_value = value;
86
87 err = test_lookup_and_delete__attach(skel);
88 if (!ASSERT_OK(err, "test_lookup_and_delete__attach"))
89 return -1;
90
91 syscall(__NR_getpgid);
92
93 test_lookup_and_delete__detach(skel);
94
95 return 0;
96 }
97
test_lookup_and_delete_hash(void)98 static void test_lookup_and_delete_hash(void)
99 {
100 struct test_lookup_and_delete *skel;
101 __u64 key, value;
102 int map_fd, err;
103
104 /* Setup program and fill the map. */
105 skel = setup_prog(BPF_MAP_TYPE_HASH, &map_fd);
106 if (!ASSERT_OK_PTR(skel, "setup_prog"))
107 return;
108
109 err = fill_values(map_fd);
110 if (!ASSERT_OK(err, "fill_values"))
111 goto cleanup;
112
113 /* Lookup and delete element. */
114 key = 1;
115 err = bpf_map_lookup_and_delete_elem(map_fd, &key, &value);
116 if (!ASSERT_OK(err, "bpf_map_lookup_and_delete_elem"))
117 goto cleanup;
118
119 /* Fetched value should match the initially set value. */
120 if (CHECK(value != START_VALUE, "bpf_map_lookup_and_delete_elem",
121 "unexpected value=%lld\n", value))
122 goto cleanup;
123
124 /* Check that the entry is non existent. */
125 err = bpf_map_lookup_elem(map_fd, &key, &value);
126 if (!ASSERT_ERR(err, "bpf_map_lookup_elem"))
127 goto cleanup;
128
129 cleanup:
130 test_lookup_and_delete__destroy(skel);
131 }
132
test_lookup_and_delete_percpu_hash(void)133 static void test_lookup_and_delete_percpu_hash(void)
134 {
135 struct test_lookup_and_delete *skel;
136 __u64 key, val, value[nr_cpus];
137 int map_fd, err, i;
138
139 /* Setup program and fill the map. */
140 skel = setup_prog(BPF_MAP_TYPE_PERCPU_HASH, &map_fd);
141 if (!ASSERT_OK_PTR(skel, "setup_prog"))
142 return;
143
144 err = fill_values_percpu(map_fd);
145 if (!ASSERT_OK(err, "fill_values_percpu"))
146 goto cleanup;
147
148 /* Lookup and delete element. */
149 key = 1;
150 err = bpf_map_lookup_and_delete_elem(map_fd, &key, value);
151 if (!ASSERT_OK(err, "bpf_map_lookup_and_delete_elem"))
152 goto cleanup;
153
154 for (i = 0; i < nr_cpus; i++) {
155 val = value[i];
156
157 /* Fetched value should match the initially set value. */
158 if (CHECK(val != START_VALUE, "map value",
159 "unexpected for cpu %d: %lld\n", i, val))
160 goto cleanup;
161 }
162
163 /* Check that the entry is non existent. */
164 err = bpf_map_lookup_elem(map_fd, &key, value);
165 if (!ASSERT_ERR(err, "bpf_map_lookup_elem"))
166 goto cleanup;
167
168 cleanup:
169 test_lookup_and_delete__destroy(skel);
170 }
171
test_lookup_and_delete_lru_hash(void)172 static void test_lookup_and_delete_lru_hash(void)
173 {
174 struct test_lookup_and_delete *skel;
175 __u64 key, value;
176 int map_fd, err;
177
178 /* Setup program and fill the LRU map. */
179 skel = setup_prog(BPF_MAP_TYPE_LRU_HASH, &map_fd);
180 if (!ASSERT_OK_PTR(skel, "setup_prog"))
181 return;
182
183 err = fill_values(map_fd);
184 if (!ASSERT_OK(err, "fill_values"))
185 goto cleanup;
186
187 /* Insert new element at key=3, should reuse LRU element. */
188 key = 3;
189 err = trigger_tp(skel, key, NEW_VALUE);
190 if (!ASSERT_OK(err, "trigger_tp"))
191 goto cleanup;
192
193 /* Lookup and delete element 3. */
194 err = bpf_map_lookup_and_delete_elem(map_fd, &key, &value);
195 if (!ASSERT_OK(err, "bpf_map_lookup_and_delete_elem"))
196 goto cleanup;
197
198 /* Value should match the new value. */
199 if (CHECK(value != NEW_VALUE, "bpf_map_lookup_and_delete_elem",
200 "unexpected value=%lld\n", value))
201 goto cleanup;
202
203 /* Check that entries 3 and 1 are non existent. */
204 err = bpf_map_lookup_elem(map_fd, &key, &value);
205 if (!ASSERT_ERR(err, "bpf_map_lookup_elem"))
206 goto cleanup;
207
208 key = 1;
209 err = bpf_map_lookup_elem(map_fd, &key, &value);
210 if (!ASSERT_ERR(err, "bpf_map_lookup_elem"))
211 goto cleanup;
212
213 cleanup:
214 test_lookup_and_delete__destroy(skel);
215 }
216
test_lookup_and_delete_lru_percpu_hash(void)217 static void test_lookup_and_delete_lru_percpu_hash(void)
218 {
219 struct test_lookup_and_delete *skel;
220 __u64 key, val, value[nr_cpus];
221 int map_fd, err, i, cpucnt = 0;
222
223 /* Setup program and fill the LRU map. */
224 skel = setup_prog(BPF_MAP_TYPE_LRU_PERCPU_HASH, &map_fd);
225 if (!ASSERT_OK_PTR(skel, "setup_prog"))
226 return;
227
228 err = fill_values_percpu(map_fd);
229 if (!ASSERT_OK(err, "fill_values_percpu"))
230 goto cleanup;
231
232 /* Insert new element at key=3, should reuse LRU element 1. */
233 key = 3;
234 err = trigger_tp(skel, key, NEW_VALUE);
235 if (!ASSERT_OK(err, "trigger_tp"))
236 goto cleanup;
237
238 /* Clean value. */
239 for (i = 0; i < nr_cpus; i++)
240 value[i] = 0;
241
242 /* Lookup and delete element 3. */
243 err = bpf_map_lookup_and_delete_elem(map_fd, &key, value);
244 if (!ASSERT_OK(err, "bpf_map_lookup_and_delete_elem")) {
245 goto cleanup;
246 }
247
248 /* Check if only one CPU has set the value. */
249 for (i = 0; i < nr_cpus; i++) {
250 val = value[i];
251 if (val) {
252 if (CHECK(val != NEW_VALUE, "map value",
253 "unexpected for cpu %d: %lld\n", i, val))
254 goto cleanup;
255 cpucnt++;
256 }
257 }
258 if (CHECK(cpucnt != 1, "map value", "set for %d CPUs instead of 1!\n",
259 cpucnt))
260 goto cleanup;
261
262 /* Check that entries 3 and 1 are non existent. */
263 err = bpf_map_lookup_elem(map_fd, &key, &value);
264 if (!ASSERT_ERR(err, "bpf_map_lookup_elem"))
265 goto cleanup;
266
267 key = 1;
268 err = bpf_map_lookup_elem(map_fd, &key, &value);
269 if (!ASSERT_ERR(err, "bpf_map_lookup_elem"))
270 goto cleanup;
271
272 cleanup:
273 test_lookup_and_delete__destroy(skel);
274 }
275
test_lookup_and_delete(void)276 void test_lookup_and_delete(void)
277 {
278 nr_cpus = bpf_num_possible_cpus();
279
280 if (test__start_subtest("lookup_and_delete"))
281 test_lookup_and_delete_hash();
282 if (test__start_subtest("lookup_and_delete_percpu"))
283 test_lookup_and_delete_percpu_hash();
284 if (test__start_subtest("lookup_and_delete_lru"))
285 test_lookup_and_delete_lru_hash();
286 if (test__start_subtest("lookup_and_delete_lru_percpu"))
287 test_lookup_and_delete_lru_percpu_hash();
288 }
289