~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/testing/selftests/bpf/test_maps.c

Version: ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Testsuite for eBPF maps
  3  *
  4  * Copyright (c) 2014 PLUMgrid, http://plumgrid.com
  5  * Copyright (c) 2016 Facebook
  6  *
  7  * This program is free software; you can redistribute it and/or
  8  * modify it under the terms of version 2 of the GNU General Public
  9  * License as published by the Free Software Foundation.
 10  */
 11 
 12 #include <stdio.h>
 13 #include <unistd.h>
 14 #include <errno.h>
 15 #include <string.h>
 16 #include <assert.h>
 17 #include <stdlib.h>
 18 
 19 #include <sys/wait.h>
 20 #include <sys/resource.h>
 21 
 22 #include <linux/bpf.h>
 23 
 24 #include <bpf/bpf.h>
 25 #include <bpf/libbpf.h>
 26 #include "bpf_util.h"
 27 
 28 static int map_flags;
 29 
 30 static void test_hashmap(int task, void *data)
 31 {
 32         long long key, next_key, first_key, value;
 33         int fd;
 34 
 35         fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
 36                             2, map_flags);
 37         if (fd < 0) {
 38                 printf("Failed to create hashmap '%s'!\n", strerror(errno));
 39                 exit(1);
 40         }
 41 
 42         key = 1;
 43         value = 1234;
 44         /* Insert key=1 element. */
 45         assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
 46 
 47         value = 0;
 48         /* BPF_NOEXIST means add new element if it doesn't exist. */
 49         assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
 50                /* key=1 already exists. */
 51                errno == EEXIST);
 52 
 53         /* -1 is an invalid flag. */
 54         assert(bpf_map_update_elem(fd, &key, &value, -1) == -1 &&
 55                errno == EINVAL);
 56 
 57         /* Check that key=1 can be found. */
 58         assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 1234);
 59 
 60         key = 2;
 61         /* Check that key=2 is not found. */
 62         assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
 63 
 64         /* BPF_EXIST means update existing element. */
 65         assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) == -1 &&
 66                /* key=2 is not there. */
 67                errno == ENOENT);
 68 
 69         /* Insert key=2 element. */
 70         assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == 0);
 71 
 72         /* key=1 and key=2 were inserted, check that key=0 cannot be
 73          * inserted due to max_entries limit.
 74          */
 75         key = 0;
 76         assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
 77                errno == E2BIG);
 78 
 79         /* Update existing element, though the map is full. */
 80         key = 1;
 81         assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) == 0);
 82         key = 2;
 83         assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
 84         key = 3;
 85         assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
 86                errno == E2BIG);
 87 
 88         /* Check that key = 0 doesn't exist. */
 89         key = 0;
 90         assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
 91 
 92         /* Iterate over two elements. */
 93         assert(bpf_map_get_next_key(fd, NULL, &first_key) == 0 &&
 94                (first_key == 1 || first_key == 2));
 95         assert(bpf_map_get_next_key(fd, &key, &next_key) == 0 &&
 96                (next_key == first_key));
 97         assert(bpf_map_get_next_key(fd, &next_key, &next_key) == 0 &&
 98                (next_key == 1 || next_key == 2) &&
 99                (next_key != first_key));
100         assert(bpf_map_get_next_key(fd, &next_key, &next_key) == -1 &&
101                errno == ENOENT);
102 
103         /* Delete both elements. */
104         key = 1;
105         assert(bpf_map_delete_elem(fd, &key) == 0);
106         key = 2;
107         assert(bpf_map_delete_elem(fd, &key) == 0);
108         assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
109 
110         key = 0;
111         /* Check that map is empty. */
112         assert(bpf_map_get_next_key(fd, NULL, &next_key) == -1 &&
113                errno == ENOENT);
114         assert(bpf_map_get_next_key(fd, &key, &next_key) == -1 &&
115                errno == ENOENT);
116 
117         close(fd);
118 }
119 
120 static void test_hashmap_sizes(int task, void *data)
121 {
122         int fd, i, j;
123 
124         for (i = 1; i <= 512; i <<= 1)
125                 for (j = 1; j <= 1 << 18; j <<= 1) {
126                         fd = bpf_create_map(BPF_MAP_TYPE_HASH, i, j,
127                                             2, map_flags);
128                         if (fd < 0) {
129                                 if (errno == ENOMEM)
130                                         return;
131                                 printf("Failed to create hashmap key=%d value=%d '%s'\n",
132                                        i, j, strerror(errno));
133                                 exit(1);
134                         }
135                         close(fd);
136                         usleep(10); /* give kernel time to destroy */
137                 }
138 }
139 
140 static void test_hashmap_percpu(int task, void *data)
141 {
142         unsigned int nr_cpus = bpf_num_possible_cpus();
143         BPF_DECLARE_PERCPU(long, value);
144         long long key, next_key, first_key;
145         int expected_key_mask = 0;
146         int fd, i;
147 
148         fd = bpf_create_map(BPF_MAP_TYPE_PERCPU_HASH, sizeof(key),
149                             sizeof(bpf_percpu(value, 0)), 2, map_flags);
150         if (fd < 0) {
151                 printf("Failed to create hashmap '%s'!\n", strerror(errno));
152                 exit(1);
153         }
154 
155         for (i = 0; i < nr_cpus; i++)
156                 bpf_percpu(value, i) = i + 100;
157 
158         key = 1;
159         /* Insert key=1 element. */
160         assert(!(expected_key_mask & key));
161         assert(bpf_map_update_elem(fd, &key, value, BPF_ANY) == 0);
162         expected_key_mask |= key;
163 
164         /* BPF_NOEXIST means add new element if it doesn't exist. */
165         assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) == -1 &&
166                /* key=1 already exists. */
167                errno == EEXIST);
168 
169         /* -1 is an invalid flag. */
170         assert(bpf_map_update_elem(fd, &key, value, -1) == -1 &&
171                errno == EINVAL);
172 
173         /* Check that key=1 can be found. Value could be 0 if the lookup
174          * was run from a different CPU.
175          */
176         bpf_percpu(value, 0) = 1;
177         assert(bpf_map_lookup_elem(fd, &key, value) == 0 &&
178                bpf_percpu(value, 0) == 100);
179 
180         key = 2;
181         /* Check that key=2 is not found. */
182         assert(bpf_map_lookup_elem(fd, &key, value) == -1 && errno == ENOENT);
183 
184         /* BPF_EXIST means update existing element. */
185         assert(bpf_map_update_elem(fd, &key, value, BPF_EXIST) == -1 &&
186                /* key=2 is not there. */
187                errno == ENOENT);
188 
189         /* Insert key=2 element. */
190         assert(!(expected_key_mask & key));
191         assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) == 0);
192         expected_key_mask |= key;
193 
194         /* key=1 and key=2 were inserted, check that key=0 cannot be
195          * inserted due to max_entries limit.
196          */
197         key = 0;
198         assert(bpf_map_update_elem(fd, &key, value, BPF_NOEXIST) == -1 &&
199                errno == E2BIG);
200 
201         /* Check that key = 0 doesn't exist. */
202         assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
203 
204         /* Iterate over two elements. */
205         assert(bpf_map_get_next_key(fd, NULL, &first_key) == 0 &&
206                ((expected_key_mask & first_key) == first_key));
207         while (!bpf_map_get_next_key(fd, &key, &next_key)) {
208                 if (first_key) {
209                         assert(next_key == first_key);
210                         first_key = 0;
211                 }
212                 assert((expected_key_mask & next_key) == next_key);
213                 expected_key_mask &= ~next_key;
214 
215                 assert(bpf_map_lookup_elem(fd, &next_key, value) == 0);
216 
217                 for (i = 0; i < nr_cpus; i++)
218                         assert(bpf_percpu(value, i) == i + 100);
219 
220                 key = next_key;
221         }
222         assert(errno == ENOENT);
223 
224         /* Update with BPF_EXIST. */
225         key = 1;
226         assert(bpf_map_update_elem(fd, &key, value, BPF_EXIST) == 0);
227 
228         /* Delete both elements. */
229         key = 1;
230         assert(bpf_map_delete_elem(fd, &key) == 0);
231         key = 2;
232         assert(bpf_map_delete_elem(fd, &key) == 0);
233         assert(bpf_map_delete_elem(fd, &key) == -1 && errno == ENOENT);
234 
235         key = 0;
236         /* Check that map is empty. */
237         assert(bpf_map_get_next_key(fd, NULL, &next_key) == -1 &&
238                errno == ENOENT);
239         assert(bpf_map_get_next_key(fd, &key, &next_key) == -1 &&
240                errno == ENOENT);
241 
242         close(fd);
243 }
244 
245 static void test_hashmap_walk(int task, void *data)
246 {
247         int fd, i, max_entries = 1000;
248         long long key, value, next_key;
249         bool next_key_valid = true;
250 
251         fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
252                             max_entries, map_flags);
253         if (fd < 0) {
254                 printf("Failed to create hashmap '%s'!\n", strerror(errno));
255                 exit(1);
256         }
257 
258         for (i = 0; i < max_entries; i++) {
259                 key = i; value = key;
260                 assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == 0);
261         }
262 
263         for (i = 0; bpf_map_get_next_key(fd, !i ? NULL : &key,
264                                          &next_key) == 0; i++) {
265                 key = next_key;
266                 assert(bpf_map_lookup_elem(fd, &key, &value) == 0);
267         }
268 
269         assert(i == max_entries);
270 
271         assert(bpf_map_get_next_key(fd, NULL, &key) == 0);
272         for (i = 0; next_key_valid; i++) {
273                 next_key_valid = bpf_map_get_next_key(fd, &key, &next_key) == 0;
274                 assert(bpf_map_lookup_elem(fd, &key, &value) == 0);
275                 value++;
276                 assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) == 0);
277                 key = next_key;
278         }
279 
280         assert(i == max_entries);
281 
282         for (i = 0; bpf_map_get_next_key(fd, !i ? NULL : &key,
283                                          &next_key) == 0; i++) {
284                 key = next_key;
285                 assert(bpf_map_lookup_elem(fd, &key, &value) == 0);
286                 assert(value - 1 == key);
287         }
288 
289         assert(i == max_entries);
290         close(fd);
291 }
292 
293 static void test_arraymap(int task, void *data)
294 {
295         int key, next_key, fd;
296         long long value;
297 
298         fd = bpf_create_map(BPF_MAP_TYPE_ARRAY, sizeof(key), sizeof(value),
299                             2, 0);
300         if (fd < 0) {
301                 printf("Failed to create arraymap '%s'!\n", strerror(errno));
302                 exit(1);
303         }
304 
305         key = 1;
306         value = 1234;
307         /* Insert key=1 element. */
308         assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
309 
310         value = 0;
311         assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
312                errno == EEXIST);
313 
314         /* Check that key=1 can be found. */
315         assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 1234);
316 
317         key = 0;
318         /* Check that key=0 is also found and zero initialized. */
319         assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 0);
320 
321         /* key=0 and key=1 were inserted, check that key=2 cannot be inserted
322          * due to max_entries limit.
323          */
324         key = 2;
325         assert(bpf_map_update_elem(fd, &key, &value, BPF_EXIST) == -1 &&
326                errno == E2BIG);
327 
328         /* Check that key = 2 doesn't exist. */
329         assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
330 
331         /* Iterate over two elements. */
332         assert(bpf_map_get_next_key(fd, NULL, &next_key) == 0 &&
333                next_key == 0);
334         assert(bpf_map_get_next_key(fd, &key, &next_key) == 0 &&
335                next_key == 0);
336         assert(bpf_map_get_next_key(fd, &next_key, &next_key) == 0 &&
337                next_key == 1);
338         assert(bpf_map_get_next_key(fd, &next_key, &next_key) == -1 &&
339                errno == ENOENT);
340 
341         /* Delete shouldn't succeed. */
342         key = 1;
343         assert(bpf_map_delete_elem(fd, &key) == -1 && errno == EINVAL);
344 
345         close(fd);
346 }
347 
348 static void test_arraymap_percpu(int task, void *data)
349 {
350         unsigned int nr_cpus = bpf_num_possible_cpus();
351         BPF_DECLARE_PERCPU(long, values);
352         int key, next_key, fd, i;
353 
354         fd = bpf_create_map(BPF_MAP_TYPE_PERCPU_ARRAY, sizeof(key),
355                             sizeof(bpf_percpu(values, 0)), 2, 0);
356         if (fd < 0) {
357                 printf("Failed to create arraymap '%s'!\n", strerror(errno));
358                 exit(1);
359         }
360 
361         for (i = 0; i < nr_cpus; i++)
362                 bpf_percpu(values, i) = i + 100;
363 
364         key = 1;
365         /* Insert key=1 element. */
366         assert(bpf_map_update_elem(fd, &key, values, BPF_ANY) == 0);
367 
368         bpf_percpu(values, 0) = 0;
369         assert(bpf_map_update_elem(fd, &key, values, BPF_NOEXIST) == -1 &&
370                errno == EEXIST);
371 
372         /* Check that key=1 can be found. */
373         assert(bpf_map_lookup_elem(fd, &key, values) == 0 &&
374                bpf_percpu(values, 0) == 100);
375 
376         key = 0;
377         /* Check that key=0 is also found and zero initialized. */
378         assert(bpf_map_lookup_elem(fd, &key, values) == 0 &&
379                bpf_percpu(values, 0) == 0 &&
380                bpf_percpu(values, nr_cpus - 1) == 0);
381 
382         /* Check that key=2 cannot be inserted due to max_entries limit. */
383         key = 2;
384         assert(bpf_map_update_elem(fd, &key, values, BPF_EXIST) == -1 &&
385                errno == E2BIG);
386 
387         /* Check that key = 2 doesn't exist. */
388         assert(bpf_map_lookup_elem(fd, &key, values) == -1 && errno == ENOENT);
389 
390         /* Iterate over two elements. */
391         assert(bpf_map_get_next_key(fd, NULL, &next_key) == 0 &&
392                next_key == 0);
393         assert(bpf_map_get_next_key(fd, &key, &next_key) == 0 &&
394                next_key == 0);
395         assert(bpf_map_get_next_key(fd, &next_key, &next_key) == 0 &&
396                next_key == 1);
397         assert(bpf_map_get_next_key(fd, &next_key, &next_key) == -1 &&
398                errno == ENOENT);
399 
400         /* Delete shouldn't succeed. */
401         key = 1;
402         assert(bpf_map_delete_elem(fd, &key) == -1 && errno == EINVAL);
403 
404         close(fd);
405 }
406 
407 static void test_arraymap_percpu_many_keys(void)
408 {
409         unsigned int nr_cpus = bpf_num_possible_cpus();
410         BPF_DECLARE_PERCPU(long, values);
411         /* nr_keys is not too large otherwise the test stresses percpu
412          * allocator more than anything else
413          */
414         unsigned int nr_keys = 2000;
415         int key, fd, i;
416 
417         fd = bpf_create_map(BPF_MAP_TYPE_PERCPU_ARRAY, sizeof(key),
418                             sizeof(bpf_percpu(values, 0)), nr_keys, 0);
419         if (fd < 0) {
420                 printf("Failed to create per-cpu arraymap '%s'!\n",
421                        strerror(errno));
422                 exit(1);
423         }
424 
425         for (i = 0; i < nr_cpus; i++)
426                 bpf_percpu(values, i) = i + 10;
427 
428         for (key = 0; key < nr_keys; key++)
429                 assert(bpf_map_update_elem(fd, &key, values, BPF_ANY) == 0);
430 
431         for (key = 0; key < nr_keys; key++) {
432                 for (i = 0; i < nr_cpus; i++)
433                         bpf_percpu(values, i) = 0;
434 
435                 assert(bpf_map_lookup_elem(fd, &key, values) == 0);
436 
437                 for (i = 0; i < nr_cpus; i++)
438                         assert(bpf_percpu(values, i) == i + 10);
439         }
440 
441         close(fd);
442 }
443 
444 static void test_devmap(int task, void *data)
445 {
446         int fd;
447         __u32 key, value;
448 
449         fd = bpf_create_map(BPF_MAP_TYPE_DEVMAP, sizeof(key), sizeof(value),
450                             2, 0);
451         if (fd < 0) {
452                 printf("Failed to create arraymap '%s'!\n", strerror(errno));
453                 exit(1);
454         }
455 
456         close(fd);
457 }
458 
459 #include <sys/socket.h>
460 #include <sys/ioctl.h>
461 #include <arpa/inet.h>
462 #include <sys/select.h>
463 #include <linux/err.h>
464 #define SOCKMAP_PARSE_PROG "./sockmap_parse_prog.o"
465 #define SOCKMAP_VERDICT_PROG "./sockmap_verdict_prog.o"
466 static void test_sockmap(int tasks, void *data)
467 {
468         int one = 1, map_fd_rx = 0, map_fd_tx = 0, map_fd_break, s, sc, rc;
469         struct bpf_map *bpf_map_rx, *bpf_map_tx, *bpf_map_break;
470         int ports[] = {50200, 50201, 50202, 50204};
471         int err, i, fd, udp, sfd[6] = {0xdeadbeef};
472         u8 buf[20] = {0x0, 0x5, 0x3, 0x2, 0x1, 0x0};
473         int parse_prog, verdict_prog;
474         struct sockaddr_in addr;
475         struct bpf_object *obj;
476         struct timeval to;
477         __u32 key, value;
478         pid_t pid[tasks];
479         fd_set w;
480 
481         /* Create some sockets to use with sockmap */
482         for (i = 0; i < 2; i++) {
483                 sfd[i] = socket(AF_INET, SOCK_STREAM, 0);
484                 if (sfd[i] < 0)
485                         goto out;
486                 err = setsockopt(sfd[i], SOL_SOCKET, SO_REUSEADDR,
487                                  (char *)&one, sizeof(one));
488                 if (err) {
489                         printf("failed to setsockopt\n");
490                         goto out;
491                 }
492                 err = ioctl(sfd[i], FIONBIO, (char *)&one);
493                 if (err < 0) {
494                         printf("failed to ioctl\n");
495                         goto out;
496                 }
497                 memset(&addr, 0, sizeof(struct sockaddr_in));
498                 addr.sin_family = AF_INET;
499                 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
500                 addr.sin_port = htons(ports[i]);
501                 err = bind(sfd[i], (struct sockaddr *)&addr, sizeof(addr));
502                 if (err < 0) {
503                         printf("failed to bind: err %i: %i:%i\n",
504                                err, i, sfd[i]);
505                         goto out;
506                 }
507                 err = listen(sfd[i], 32);
508                 if (err < 0) {
509                         printf("failed to listen\n");
510                         goto out;
511                 }
512         }
513 
514         for (i = 2; i < 4; i++) {
515                 sfd[i] = socket(AF_INET, SOCK_STREAM, 0);
516                 if (sfd[i] < 0)
517                         goto out;
518                 err = setsockopt(sfd[i], SOL_SOCKET, SO_REUSEADDR,
519                                  (char *)&one, sizeof(one));
520                 if (err) {
521                         printf("set sock opt\n");
522                         goto out;
523                 }
524                 memset(&addr, 0, sizeof(struct sockaddr_in));
525                 addr.sin_family = AF_INET;
526                 addr.sin_addr.s_addr = inet_addr("127.0.0.1");
527                 addr.sin_port = htons(ports[i - 2]);
528                 err = connect(sfd[i], (struct sockaddr *)&addr, sizeof(addr));
529                 if (err) {
530                         printf("failed to connect\n");
531                         goto out;
532                 }
533         }
534 
535 
536         for (i = 4; i < 6; i++) {
537                 sfd[i] = accept(sfd[i - 4], NULL, NULL);
538                 if (sfd[i] < 0) {
539                         printf("accept failed\n");
540                         goto out;
541                 }
542         }
543 
544         /* Test sockmap with connected sockets */
545         fd = bpf_create_map(BPF_MAP_TYPE_SOCKMAP,
546                             sizeof(key), sizeof(value),
547                             6, 0);
548         if (fd < 0) {
549                 printf("Failed to create sockmap %i\n", fd);
550                 goto out_sockmap;
551         }
552 
553         /* Test update with unsupported UDP socket */
554         udp = socket(AF_INET, SOCK_DGRAM, 0);
555         i = 0;
556         err = bpf_map_update_elem(fd, &i, &udp, BPF_ANY);
557         if (!err) {
558                 printf("Failed socket SOCK_DGRAM allowed '%i:%i'\n",
559                        i, udp);
560                 goto out_sockmap;
561         }
562 
563         /* Test update without programs */
564         for (i = 0; i < 6; i++) {
565                 err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);
566                 if (err) {
567                         printf("Failed noprog update sockmap '%i:%i'\n",
568                                i, sfd[i]);
569                         goto out_sockmap;
570                 }
571         }
572 
573         /* Test attaching/detaching bad fds */
574         err = bpf_prog_attach(-1, fd, BPF_SK_SKB_STREAM_PARSER, 0);
575         if (!err) {
576                 printf("Failed invalid parser prog attach\n");
577                 goto out_sockmap;
578         }
579 
580         err = bpf_prog_attach(-1, fd, BPF_SK_SKB_STREAM_VERDICT, 0);
581         if (!err) {
582                 printf("Failed invalid verdict prog attach\n");
583                 goto out_sockmap;
584         }
585 
586         err = bpf_prog_attach(-1, fd, __MAX_BPF_ATTACH_TYPE, 0);
587         if (!err) {
588                 printf("Failed unknown prog attach\n");
589                 goto out_sockmap;
590         }
591 
592         err = bpf_prog_detach(fd, BPF_SK_SKB_STREAM_PARSER);
593         if (err) {
594                 printf("Failed empty parser prog detach\n");
595                 goto out_sockmap;
596         }
597 
598         err = bpf_prog_detach(fd, BPF_SK_SKB_STREAM_VERDICT);
599         if (err) {
600                 printf("Failed empty verdict prog detach\n");
601                 goto out_sockmap;
602         }
603 
604         err = bpf_prog_detach(fd, __MAX_BPF_ATTACH_TYPE);
605         if (!err) {
606                 printf("Detach invalid prog successful\n");
607                 goto out_sockmap;
608         }
609 
610         /* Load SK_SKB program and Attach */
611         err = bpf_prog_load(SOCKMAP_PARSE_PROG,
612                             BPF_PROG_TYPE_SK_SKB, &obj, &parse_prog);
613         if (err) {
614                 printf("Failed to load SK_SKB parse prog\n");
615                 goto out_sockmap;
616         }
617 
618         err = bpf_prog_load(SOCKMAP_VERDICT_PROG,
619                             BPF_PROG_TYPE_SK_SKB, &obj, &verdict_prog);
620         if (err) {
621                 printf("Failed to load SK_SKB verdict prog\n");
622                 goto out_sockmap;
623         }
624 
625         bpf_map_rx = bpf_object__find_map_by_name(obj, "sock_map_rx");
626         if (IS_ERR(bpf_map_rx)) {
627                 printf("Failed to load map rx from verdict prog\n");
628                 goto out_sockmap;
629         }
630 
631         map_fd_rx = bpf_map__fd(bpf_map_rx);
632         if (map_fd_rx < 0) {
633                 printf("Failed to get map fd\n");
634                 goto out_sockmap;
635         }
636 
637         bpf_map_tx = bpf_object__find_map_by_name(obj, "sock_map_tx");
638         if (IS_ERR(bpf_map_tx)) {
639                 printf("Failed to load map tx from verdict prog\n");
640                 goto out_sockmap;
641         }
642 
643         map_fd_tx = bpf_map__fd(bpf_map_tx);
644         if (map_fd_tx < 0) {
645                 printf("Failed to get map tx fd\n");
646                 goto out_sockmap;
647         }
648 
649         bpf_map_break = bpf_object__find_map_by_name(obj, "sock_map_break");
650         if (IS_ERR(bpf_map_break)) {
651                 printf("Failed to load map tx from verdict prog\n");
652                 goto out_sockmap;
653         }
654 
655         map_fd_break = bpf_map__fd(bpf_map_break);
656         if (map_fd_break < 0) {
657                 printf("Failed to get map tx fd\n");
658                 goto out_sockmap;
659         }
660 
661         err = bpf_prog_attach(parse_prog, map_fd_break,
662                               BPF_SK_SKB_STREAM_PARSER, 0);
663         if (!err) {
664                 printf("Allowed attaching SK_SKB program to invalid map\n");
665                 goto out_sockmap;
666         }
667 
668         err = bpf_prog_attach(parse_prog, map_fd_rx,
669                       BPF_SK_SKB_STREAM_PARSER, 0);
670         if (err) {
671                 printf("Failed stream parser bpf prog attach\n");
672                 goto out_sockmap;
673         }
674 
675         err = bpf_prog_attach(verdict_prog, map_fd_rx,
676                               BPF_SK_SKB_STREAM_VERDICT, 0);
677         if (err) {
678                 printf("Failed stream verdict bpf prog attach\n");
679                 goto out_sockmap;
680         }
681 
682         err = bpf_prog_attach(verdict_prog, map_fd_rx,
683                               __MAX_BPF_ATTACH_TYPE, 0);
684         if (!err) {
685                 printf("Attached unknown bpf prog\n");
686                 goto out_sockmap;
687         }
688 
689         /* Test map update elem afterwards fd lives in fd and map_fd */
690         for (i = 0; i < 6; i++) {
691                 err = bpf_map_update_elem(map_fd_rx, &i, &sfd[i], BPF_ANY);
692                 if (err) {
693                         printf("Failed map_fd_rx update sockmap %i '%i:%i'\n",
694                                err, i, sfd[i]);
695                         goto out_sockmap;
696                 }
697                 err = bpf_map_update_elem(map_fd_tx, &i, &sfd[i], BPF_ANY);
698                 if (err) {
699                         printf("Failed map_fd_tx update sockmap %i '%i:%i'\n",
700                                err, i, sfd[i]);
701                         goto out_sockmap;
702                 }
703         }
704 
705         /* Test map delete elem and remove send/recv sockets */
706         for (i = 2; i < 4; i++) {
707                 err = bpf_map_delete_elem(map_fd_rx, &i);
708                 if (err) {
709                         printf("Failed delete sockmap rx %i '%i:%i'\n",
710                                err, i, sfd[i]);
711                         goto out_sockmap;
712                 }
713                 err = bpf_map_delete_elem(map_fd_tx, &i);
714                 if (err) {
715                         printf("Failed delete sockmap tx %i '%i:%i'\n",
716                                err, i, sfd[i]);
717                         goto out_sockmap;
718                 }
719         }
720 
721         /* Test map send/recv */
722         for (i = 0; i < 2; i++) {
723                 buf[0] = i;
724                 buf[1] = 0x5;
725                 sc = send(sfd[2], buf, 20, 0);
726                 if (sc < 0) {
727                         printf("Failed sockmap send\n");
728                         goto out_sockmap;
729                 }
730 
731                 FD_ZERO(&w);
732                 FD_SET(sfd[3], &w);
733                 to.tv_sec = 1;
734                 to.tv_usec = 0;
735                 s = select(sfd[3] + 1, &w, NULL, NULL, &to);
736                 if (s == -1) {
737                         perror("Failed sockmap select()");
738                         goto out_sockmap;
739                 } else if (!s) {
740                         printf("Failed sockmap unexpected timeout\n");
741                         goto out_sockmap;
742                 }
743 
744                 if (!FD_ISSET(sfd[3], &w)) {
745                         printf("Failed sockmap select/recv\n");
746                         goto out_sockmap;
747                 }
748 
749                 rc = recv(sfd[3], buf, sizeof(buf), 0);
750                 if (rc < 0) {
751                         printf("Failed sockmap recv\n");
752                         goto out_sockmap;
753                 }
754         }
755 
756         /* Negative null entry lookup from datapath should be dropped */
757         buf[0] = 1;
758         buf[1] = 12;
759         sc = send(sfd[2], buf, 20, 0);
760         if (sc < 0) {
761                 printf("Failed sockmap send\n");
762                 goto out_sockmap;
763         }
764 
765         /* Push fd into same slot */
766         i = 2;
767         err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_NOEXIST);
768         if (!err) {
769                 printf("Failed allowed sockmap dup slot BPF_NOEXIST\n");
770                 goto out_sockmap;
771         }
772 
773         err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);
774         if (err) {
775                 printf("Failed sockmap update new slot BPF_ANY\n");
776                 goto out_sockmap;
777         }
778 
779         err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_EXIST);
780         if (err) {
781                 printf("Failed sockmap update new slot BPF_EXIST\n");
782                 goto out_sockmap;
783         }
784 
785         /* Delete the elems without programs */
786         for (i = 0; i < 6; i++) {
787                 err = bpf_map_delete_elem(fd, &i);
788                 if (err) {
789                         printf("Failed delete sockmap %i '%i:%i'\n",
790                                err, i, sfd[i]);
791                 }
792         }
793 
794         /* Test having multiple maps open and set with programs on same fds */
795         err = bpf_prog_attach(parse_prog, fd,
796                               BPF_SK_SKB_STREAM_PARSER, 0);
797         if (err) {
798                 printf("Failed fd bpf parse prog attach\n");
799                 goto out_sockmap;
800         }
801         err = bpf_prog_attach(verdict_prog, fd,
802                               BPF_SK_SKB_STREAM_VERDICT, 0);
803         if (err) {
804                 printf("Failed fd bpf verdict prog attach\n");
805                 goto out_sockmap;
806         }
807 
808         for (i = 4; i < 6; i++) {
809                 err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_ANY);
810                 if (!err) {
811                         printf("Failed allowed duplicate programs in update ANY sockmap %i '%i:%i'\n",
812                                err, i, sfd[i]);
813                         goto out_sockmap;
814                 }
815                 err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_NOEXIST);
816                 if (!err) {
817                         printf("Failed allowed duplicate program in update NOEXIST sockmap  %i '%i:%i'\n",
818                                err, i, sfd[i]);
819                         goto out_sockmap;
820                 }
821                 err = bpf_map_update_elem(fd, &i, &sfd[i], BPF_EXIST);
822                 if (!err) {
823                         printf("Failed allowed duplicate program in update EXIST sockmap  %i '%i:%i'\n",
824                                err, i, sfd[i]);
825                         goto out_sockmap;
826                 }
827         }
828 
829         /* Test tasks number of forked operations */
830         for (i = 0; i < tasks; i++) {
831                 pid[i] = fork();
832                 if (pid[i] == 0) {
833                         for (i = 0; i < 6; i++) {
834                                 bpf_map_delete_elem(map_fd_tx, &i);
835                                 bpf_map_delete_elem(map_fd_rx, &i);
836                                 bpf_map_update_elem(map_fd_tx, &i,
837                                                     &sfd[i], BPF_ANY);
838                                 bpf_map_update_elem(map_fd_rx, &i,
839                                                     &sfd[i], BPF_ANY);
840                         }
841                         exit(0);
842                 } else if (pid[i] == -1) {
843                         printf("Couldn't spawn #%d process!\n", i);
844                         exit(1);
845                 }
846         }
847 
848         for (i = 0; i < tasks; i++) {
849                 int status;
850 
851                 assert(waitpid(pid[i], &status, 0) == pid[i]);
852                 assert(status == 0);
853         }
854 
855         err = bpf_prog_detach(map_fd_rx, __MAX_BPF_ATTACH_TYPE);
856         if (!err) {
857                 printf("Detached an invalid prog type.\n");
858                 goto out_sockmap;
859         }
860 
861         err = bpf_prog_detach(map_fd_rx, BPF_SK_SKB_STREAM_PARSER);
862         if (err) {
863                 printf("Failed parser prog detach\n");
864                 goto out_sockmap;
865         }
866 
867         err = bpf_prog_detach(map_fd_rx, BPF_SK_SKB_STREAM_VERDICT);
868         if (err) {
869                 printf("Failed parser prog detach\n");
870                 goto out_sockmap;
871         }
872 
873         /* Test map close sockets and empty maps */
874         for (i = 0; i < 6; i++) {
875                 bpf_map_delete_elem(map_fd_tx, &i);
876                 bpf_map_delete_elem(map_fd_rx, &i);
877                 close(sfd[i]);
878         }
879         close(fd);
880         close(map_fd_rx);
881         bpf_object__close(obj);
882         return;
883 out:
884         for (i = 0; i < 6; i++)
885                 close(sfd[i]);
886         printf("Failed to create sockmap '%i:%s'!\n", i, strerror(errno));
887         exit(1);
888 out_sockmap:
889         for (i = 0; i < 6; i++) {
890                 if (map_fd_tx)
891                         bpf_map_delete_elem(map_fd_tx, &i);
892                 if (map_fd_rx)
893                         bpf_map_delete_elem(map_fd_rx, &i);
894                 close(sfd[i]);
895         }
896         close(fd);
897         exit(1);
898 }
899 
900 #define MAP_SIZE (32 * 1024)
901 
902 static void test_map_large(void)
903 {
904         struct bigkey {
905                 int a;
906                 char b[116];
907                 long long c;
908         } key;
909         int fd, i, value;
910 
911         fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
912                             MAP_SIZE, map_flags);
913         if (fd < 0) {
914                 printf("Failed to create large map '%s'!\n", strerror(errno));
915                 exit(1);
916         }
917 
918         for (i = 0; i < MAP_SIZE; i++) {
919                 key = (struct bigkey) { .c = i };
920                 value = i;
921 
922                 assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == 0);
923         }
924 
925         key.c = -1;
926         assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
927                errno == E2BIG);
928 
929         /* Iterate through all elements. */
930         assert(bpf_map_get_next_key(fd, NULL, &key) == 0);
931         key.c = -1;
932         for (i = 0; i < MAP_SIZE; i++)
933                 assert(bpf_map_get_next_key(fd, &key, &key) == 0);
934         assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
935 
936         key.c = 0;
937         assert(bpf_map_lookup_elem(fd, &key, &value) == 0 && value == 0);
938         key.a = 1;
939         assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
940 
941         close(fd);
942 }
943 
944 #define run_parallel(N, FN, DATA) \
945         printf("Fork %d tasks to '" #FN "'\n", N); \
946         __run_parallel(N, FN, DATA)
947 
948 static void __run_parallel(int tasks, void (*fn)(int task, void *data),
949                            void *data)
950 {
951         pid_t pid[tasks];
952         int i;
953 
954         for (i = 0; i < tasks; i++) {
955                 pid[i] = fork();
956                 if (pid[i] == 0) {
957                         fn(i, data);
958                         exit(0);
959                 } else if (pid[i] == -1) {
960                         printf("Couldn't spawn #%d process!\n", i);
961                         exit(1);
962                 }
963         }
964 
965         for (i = 0; i < tasks; i++) {
966                 int status;
967 
968                 assert(waitpid(pid[i], &status, 0) == pid[i]);
969                 assert(status == 0);
970         }
971 }
972 
973 static void test_map_stress(void)
974 {
975         run_parallel(100, test_hashmap, NULL);
976         run_parallel(100, test_hashmap_percpu, NULL);
977         run_parallel(100, test_hashmap_sizes, NULL);
978         run_parallel(100, test_hashmap_walk, NULL);
979 
980         run_parallel(100, test_arraymap, NULL);
981         run_parallel(100, test_arraymap_percpu, NULL);
982 }
983 
984 #define TASKS 1024
985 
986 #define DO_UPDATE 1
987 #define DO_DELETE 0
988 
989 static void test_update_delete(int fn, void *data)
990 {
991         int do_update = ((int *)data)[1];
992         int fd = ((int *)data)[0];
993         int i, key, value;
994 
995         for (i = fn; i < MAP_SIZE; i += TASKS) {
996                 key = value = i;
997 
998                 if (do_update) {
999                         assert(bpf_map_update_elem(fd, &key, &value,
1000                                                    BPF_NOEXIST) == 0);
1001                         assert(bpf_map_update_elem(fd, &key, &value,
1002                                                    BPF_EXIST) == 0);
1003                 } else {
1004                         assert(bpf_map_delete_elem(fd, &key) == 0);
1005                 }
1006         }
1007 }
1008 
1009 static void test_map_parallel(void)
1010 {
1011         int i, fd, key = 0, value = 0;
1012         int data[2];
1013 
1014         fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
1015                             MAP_SIZE, map_flags);
1016         if (fd < 0) {
1017                 printf("Failed to create map for parallel test '%s'!\n",
1018                        strerror(errno));
1019                 exit(1);
1020         }
1021 
1022         /* Use the same fd in children to add elements to this map:
1023          * child_0 adds key=0, key=1024, key=2048, ...
1024          * child_1 adds key=1, key=1025, key=2049, ...
1025          * child_1023 adds key=1023, ...
1026          */
1027         data[0] = fd;
1028         data[1] = DO_UPDATE;
1029         run_parallel(TASKS, test_update_delete, data);
1030 
1031         /* Check that key=0 is already there. */
1032         assert(bpf_map_update_elem(fd, &key, &value, BPF_NOEXIST) == -1 &&
1033                errno == EEXIST);
1034 
1035         /* Check that all elements were inserted. */
1036         assert(bpf_map_get_next_key(fd, NULL, &key) == 0);
1037         key = -1;
1038         for (i = 0; i < MAP_SIZE; i++)
1039                 assert(bpf_map_get_next_key(fd, &key, &key) == 0);
1040         assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
1041 
1042         /* Another check for all elements */
1043         for (i = 0; i < MAP_SIZE; i++) {
1044                 key = MAP_SIZE - i - 1;
1045 
1046                 assert(bpf_map_lookup_elem(fd, &key, &value) == 0 &&
1047                        value == key);
1048         }
1049 
1050         /* Now let's delete all elemenets in parallel. */
1051         data[1] = DO_DELETE;
1052         run_parallel(TASKS, test_update_delete, data);
1053 
1054         /* Nothing should be left. */
1055         key = -1;
1056         assert(bpf_map_get_next_key(fd, NULL, &key) == -1 && errno == ENOENT);
1057         assert(bpf_map_get_next_key(fd, &key, &key) == -1 && errno == ENOENT);
1058 }
1059 
1060 static void test_map_rdonly(void)
1061 {
1062         int fd, key = 0, value = 0;
1063 
1064         fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
1065                             MAP_SIZE, map_flags | BPF_F_RDONLY);
1066         if (fd < 0) {
1067                 printf("Failed to create map for read only test '%s'!\n",
1068                        strerror(errno));
1069                 exit(1);
1070         }
1071 
1072         key = 1;
1073         value = 1234;
1074         /* Insert key=1 element. */
1075         assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == -1 &&
1076                errno == EPERM);
1077 
1078         /* Check that key=2 is not found. */
1079         assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == ENOENT);
1080         assert(bpf_map_get_next_key(fd, &key, &value) == -1 && errno == ENOENT);
1081 }
1082 
1083 static void test_map_wronly(void)
1084 {
1085         int fd, key = 0, value = 0;
1086 
1087         fd = bpf_create_map(BPF_MAP_TYPE_HASH, sizeof(key), sizeof(value),
1088                             MAP_SIZE, map_flags | BPF_F_WRONLY);
1089         if (fd < 0) {
1090                 printf("Failed to create map for read only test '%s'!\n",
1091                        strerror(errno));
1092                 exit(1);
1093         }
1094 
1095         key = 1;
1096         value = 1234;
1097         /* Insert key=1 element. */
1098         assert(bpf_map_update_elem(fd, &key, &value, BPF_ANY) == 0);
1099 
1100         /* Check that key=2 is not found. */
1101         assert(bpf_map_lookup_elem(fd, &key, &value) == -1 && errno == EPERM);
1102         assert(bpf_map_get_next_key(fd, &key, &value) == -1 && errno == EPERM);
1103 }
1104 
1105 static void run_all_tests(void)
1106 {
1107         test_hashmap(0, NULL);
1108         test_hashmap_percpu(0, NULL);
1109         test_hashmap_walk(0, NULL);
1110 
1111         test_arraymap(0, NULL);
1112         test_arraymap_percpu(0, NULL);
1113 
1114         test_arraymap_percpu_many_keys();
1115 
1116         test_devmap(0, NULL);
1117         test_sockmap(0, NULL);
1118 
1119         test_map_large();
1120         test_map_parallel();
1121         test_map_stress();
1122 
1123         test_map_rdonly();
1124         test_map_wronly();
1125 }
1126 
1127 int main(void)
1128 {
1129         struct rlimit rinf = { RLIM_INFINITY, RLIM_INFINITY };
1130 
1131         setrlimit(RLIMIT_MEMLOCK, &rinf);
1132 
1133         map_flags = 0;
1134         run_all_tests();
1135 
1136         map_flags = BPF_F_NO_PREALLOC;
1137         run_all_tests();
1138 
1139         printf("test_maps: OK\n");
1140         return 0;
1141 }
1142 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp