1
2
3#include <stdio.h>
4#include <errno.h>
5#include <string.h>
6
7#include <bpf/bpf.h>
8#include <bpf/libbpf.h>
9
10#include <bpf_util.h>
11#include <test_maps.h>
12
13static void map_batch_update(int map_fd, __u32 max_entries, int *keys,
14 void *values, bool is_pcpu)
15{
16 typedef BPF_DECLARE_PERCPU(int, value);
17 value *v = NULL;
18 int i, j, err;
19 DECLARE_LIBBPF_OPTS(bpf_map_batch_opts, opts,
20 .elem_flags = 0,
21 .flags = 0,
22 );
23
24 if (is_pcpu)
25 v = (value *)values;
26
27 for (i = 0; i < max_entries; i++) {
28 keys[i] = i + 1;
29 if (is_pcpu)
30 for (j = 0; j < bpf_num_possible_cpus(); j++)
31 bpf_percpu(v[i], j) = i + 2 + j;
32 else
33 ((int *)values)[i] = i + 2;
34 }
35
36 err = bpf_map_update_batch(map_fd, keys, values, &max_entries, &opts);
37 CHECK(err, "bpf_map_update_batch()", "error:%s\n", strerror(errno));
38}
39
40static void map_batch_verify(int *visited, __u32 max_entries,
41 int *keys, void *values, bool is_pcpu)
42{
43 typedef BPF_DECLARE_PERCPU(int, value);
44 value *v = NULL;
45 int i, j;
46
47 if (is_pcpu)
48 v = (value *)values;
49
50 memset(visited, 0, max_entries * sizeof(*visited));
51 for (i = 0; i < max_entries; i++) {
52
53 if (is_pcpu) {
54 for (j = 0; j < bpf_num_possible_cpus(); j++) {
55 CHECK(keys[i] + 1 + j != bpf_percpu(v[i], j),
56 "key/value checking",
57 "error: i %d j %d key %d value %d\n",
58 i, j, keys[i], bpf_percpu(v[i], j));
59 }
60 } else {
61 CHECK(keys[i] + 1 != ((int *)values)[i],
62 "key/value checking",
63 "error: i %d key %d value %d\n", i, keys[i],
64 ((int *)values)[i]);
65 }
66
67 visited[i] = 1;
68
69 }
70 for (i = 0; i < max_entries; i++) {
71 CHECK(visited[i] != 1, "visited checking",
72 "error: keys array at index %d missing\n", i);
73 }
74}
75
76void __test_map_lookup_and_delete_batch(bool is_pcpu)
77{
78 __u32 batch, count, total, total_success;
79 typedef BPF_DECLARE_PERCPU(int, value);
80 int map_fd, *keys, *visited, key;
81 const __u32 max_entries = 10;
82 value pcpu_values[max_entries];
83 int err, step, value_size;
84 bool nospace_err;
85 void *values;
86 struct bpf_create_map_attr xattr = {
87 .name = "hash_map",
88 .map_type = is_pcpu ? BPF_MAP_TYPE_PERCPU_HASH :
89 BPF_MAP_TYPE_HASH,
90 .key_size = sizeof(int),
91 .value_size = sizeof(int),
92 };
93 DECLARE_LIBBPF_OPTS(bpf_map_batch_opts, opts,
94 .elem_flags = 0,
95 .flags = 0,
96 );
97
98 xattr.max_entries = max_entries;
99 map_fd = bpf_create_map_xattr(&xattr);
100 CHECK(map_fd == -1,
101 "bpf_create_map_xattr()", "error:%s\n", strerror(errno));
102
103 value_size = is_pcpu ? sizeof(value) : sizeof(int);
104 keys = malloc(max_entries * sizeof(int));
105 if (is_pcpu)
106 values = pcpu_values;
107 else
108 values = malloc(max_entries * sizeof(int));
109 visited = malloc(max_entries * sizeof(int));
110 CHECK(!keys || !values || !visited, "malloc()",
111 "error:%s\n", strerror(errno));
112
113
114 count = max_entries;
115 err = bpf_map_lookup_and_delete_batch(map_fd, NULL, &batch, keys,
116 values, &count, &opts);
117 CHECK((err && errno != ENOENT), "empty map",
118 "error: %s\n", strerror(errno));
119
120
121 map_batch_update(map_fd, max_entries, keys, values, is_pcpu);
122
123
124 count = 0;
125 err = bpf_map_lookup_and_delete_batch(map_fd, NULL, &batch, keys,
126 values, &count, &opts);
127 CHECK(err, "count = 0", "error: %s\n", strerror(errno));
128
129
130 memset(keys, 0, max_entries * sizeof(*keys));
131 memset(values, 0, max_entries * value_size);
132 count = max_entries;
133 err = bpf_map_lookup_and_delete_batch(map_fd, NULL, &batch, keys,
134 values, &count, &opts);
135 CHECK((err && errno != ENOENT), "count = max_entries",
136 "error: %s\n", strerror(errno));
137 CHECK(count != max_entries, "count = max_entries",
138 "count = %u, max_entries = %u\n", count, max_entries);
139 map_batch_verify(visited, max_entries, keys, values, is_pcpu);
140
141
142 err = bpf_map_get_next_key(map_fd, NULL, &key);
143 CHECK(!err, "bpf_map_get_next_key()", "error: %s\n", strerror(errno));
144
145
146 total_success = 0;
147 for (step = 1; step < max_entries; step++) {
148 map_batch_update(map_fd, max_entries, keys, values, is_pcpu);
149 memset(keys, 0, max_entries * sizeof(*keys));
150 memset(values, 0, max_entries * value_size);
151 total = 0;
152
153
154
155 count = step;
156 nospace_err = false;
157 while (true) {
158 err = bpf_map_lookup_batch(map_fd,
159 total ? &batch : NULL,
160 &batch, keys + total,
161 values +
162 total * value_size,
163 &count, &opts);
164
165
166
167
168
169 if (err && errno == ENOSPC) {
170 nospace_err = true;
171 break;
172 }
173
174 CHECK((err && errno != ENOENT), "lookup with steps",
175 "error: %s\n", strerror(errno));
176
177 total += count;
178 if (err)
179 break;
180
181 }
182 if (nospace_err == true)
183 continue;
184
185 CHECK(total != max_entries, "lookup with steps",
186 "total = %u, max_entries = %u\n", total, max_entries);
187 map_batch_verify(visited, max_entries, keys, values, is_pcpu);
188
189 total = 0;
190 count = step;
191 while (total < max_entries) {
192 if (max_entries - total < step)
193 count = max_entries - total;
194 err = bpf_map_delete_batch(map_fd,
195 keys + total,
196 &count, &opts);
197 CHECK((err && errno != ENOENT), "delete batch",
198 "error: %s\n", strerror(errno));
199 total += count;
200 if (err)
201 break;
202 }
203 CHECK(total != max_entries, "delete with steps",
204 "total = %u, max_entries = %u\n", total, max_entries);
205
206
207 err = bpf_map_get_next_key(map_fd, NULL, &key);
208 CHECK(!err || errno != ENOENT, "bpf_map_get_next_key()",
209 "error: %s\n", strerror(errno));
210
211
212
213
214 map_batch_update(map_fd, max_entries, keys, values, is_pcpu);
215 memset(keys, 0, max_entries * sizeof(*keys));
216 memset(values, 0, max_entries * value_size);
217 total = 0;
218 count = step;
219 nospace_err = false;
220 while (true) {
221 err = bpf_map_lookup_and_delete_batch(map_fd,
222 total ? &batch : NULL,
223 &batch, keys + total,
224 values +
225 total * value_size,
226 &count, &opts);
227
228
229
230
231
232 if (err && errno == ENOSPC) {
233 nospace_err = true;
234 break;
235 }
236
237 CHECK((err && errno != ENOENT), "lookup with steps",
238 "error: %s\n", strerror(errno));
239
240 total += count;
241 if (err)
242 break;
243 }
244
245 if (nospace_err == true)
246 continue;
247
248 CHECK(total != max_entries, "lookup/delete with steps",
249 "total = %u, max_entries = %u\n", total, max_entries);
250
251 map_batch_verify(visited, max_entries, keys, values, is_pcpu);
252 err = bpf_map_get_next_key(map_fd, NULL, &key);
253 CHECK(!err, "bpf_map_get_next_key()", "error: %s\n",
254 strerror(errno));
255
256 total_success++;
257 }
258
259 CHECK(total_success == 0, "check total_success",
260 "unexpected failure\n");
261 free(keys);
262 free(visited);
263 if (!is_pcpu)
264 free(values);
265}
266
267void htab_map_batch_ops(void)
268{
269 __test_map_lookup_and_delete_batch(false);
270 printf("test_%s:PASS\n", __func__);
271}
272
273void htab_percpu_map_batch_ops(void)
274{
275 __test_map_lookup_and_delete_batch(true);
276 printf("test_%s:PASS\n", __func__);
277}
278
279void test_htab_map_batch_ops(void)
280{
281 htab_map_batch_ops();
282 htab_percpu_map_batch_ops();
283}
284
