tools/testing/selftests/bpf/prog_tests/btf_map_in_map.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2020 Facebook */
   3
   4 #include <test_progs.h>
   5
   6 #include "test_btf_map_in_map.skel.h"
   7
   8 static int duration;
   9
  10 static __u32 bpf_map_id(struct bpf_map *map)
  11 {
  12         struct bpf_map_info info;
  13         __u32 info_len = sizeof(info);
  14         int err;
  15
  16         memset(&info, 0, info_len);
  17         err = bpf_map_get_info_by_fd(bpf_map__fd(map), &info, &info_len);
  18         if (err)
  19                 return 0;
  20         return info.id;
  21 }
  22
  23 static void test_lookup_update(void)
  24 {
  25         int map1_fd, map2_fd, map3_fd, map4_fd, map5_fd, map1_id, map2_id;
  26         int outer_arr_fd, outer_hash_fd, outer_arr_dyn_fd;
  27         struct test_btf_map_in_map *skel;
  28         int err, key = 0, val, i;
  29
  30         skel = test_btf_map_in_map__open_and_load();
  31         if (CHECK(!skel, "skel_open", "failed to open&load skeleton\n"))
  32                 return;
  33
  34         err = test_btf_map_in_map__attach(skel);
  35         if (CHECK(err, "skel_attach", "skeleton attach failed: %d\n", err))
  36                 goto cleanup;
  37
  38         map1_fd = bpf_map__fd(skel->maps.inner_map1);
  39         map2_fd = bpf_map__fd(skel->maps.inner_map2);
  40         map3_fd = bpf_map__fd(skel->maps.inner_map3);
  41         map4_fd = bpf_map__fd(skel->maps.inner_map4);
  42         map5_fd = bpf_map__fd(skel->maps.inner_map5);
  43         outer_arr_dyn_fd = bpf_map__fd(skel->maps.outer_arr_dyn);
  44         outer_arr_fd = bpf_map__fd(skel->maps.outer_arr);
  45         outer_hash_fd = bpf_map__fd(skel->maps.outer_hash);
  46
  47         /* inner1 = input, inner2 = input + 1, inner3 = input + 2 */
  48         bpf_map_update_elem(outer_arr_fd, &key, &map1_fd, 0);
  49         bpf_map_update_elem(outer_hash_fd, &key, &map2_fd, 0);
  50         bpf_map_update_elem(outer_arr_dyn_fd, &key, &map3_fd, 0);
  51         skel->bss->input = 1;
  52         usleep(1);
  53         bpf_map_lookup_elem(map1_fd, &key, &val);
  54         CHECK(val != 1, "inner1", "got %d != exp %d\n", val, 1);
  55         bpf_map_lookup_elem(map2_fd, &key, &val);
  56         CHECK(val != 2, "inner2", "got %d != exp %d\n", val, 2);
  57         bpf_map_lookup_elem(map3_fd, &key, &val);
  58         CHECK(val != 3, "inner3", "got %d != exp %d\n", val, 3);
  59
  60         /* inner2 = input, inner1 = input + 1, inner4 = input + 2 */
  61         bpf_map_update_elem(outer_arr_fd, &key, &map2_fd, 0);
  62         bpf_map_update_elem(outer_hash_fd, &key, &map1_fd, 0);
  63         bpf_map_update_elem(outer_arr_dyn_fd, &key, &map4_fd, 0);
  64         skel->bss->input = 3;
  65         usleep(1);
  66         bpf_map_lookup_elem(map1_fd, &key, &val);
  67         CHECK(val != 4, "inner1", "got %d != exp %d\n", val, 4);
  68         bpf_map_lookup_elem(map2_fd, &key, &val);
  69         CHECK(val != 3, "inner2", "got %d != exp %d\n", val, 3);
  70         bpf_map_lookup_elem(map4_fd, &key, &val);
  71         CHECK(val != 5, "inner4", "got %d != exp %d\n", val, 5);
  72
  73         /* inner5 = input + 2 */
  74         bpf_map_update_elem(outer_arr_dyn_fd, &key, &map5_fd, 0);
  75         skel->bss->input = 5;
  76         usleep(1);
  77         bpf_map_lookup_elem(map5_fd, &key, &val);
  78         CHECK(val != 7, "inner5", "got %d != exp %d\n", val, 7);
  79
  80         for (i = 0; i < 5; i++) {
  81                 val = i % 2 ? map1_fd : map2_fd;
  82                 err = bpf_map_update_elem(outer_hash_fd, &key, &val, 0);
  83                 if (CHECK_FAIL(err)) {
  84                         printf("failed to update hash_of_maps on iter #%d\n", i);
  85                         goto cleanup;
  86                 }
  87                 err = bpf_map_update_elem(outer_arr_fd, &key, &val, 0);
  88                 if (CHECK_FAIL(err)) {
  89                         printf("failed to update array_of_maps on iter #%d\n", i);
  90                         goto cleanup;
  91                 }
  92                 val = i % 2 ? map4_fd : map5_fd;
  93                 err = bpf_map_update_elem(outer_arr_dyn_fd, &key, &val, 0);
  94                 if (CHECK_FAIL(err)) {
  95                         printf("failed to update array_of_maps (dyn) on iter #%d\n", i);
  96                         goto cleanup;
  97                 }
  98         }
  99
 100         map1_id = bpf_map_id(skel->maps.inner_map1);
 101         map2_id = bpf_map_id(skel->maps.inner_map2);
 102         CHECK(map1_id == 0, "map1_id", "failed to get ID 1\n");
 103         CHECK(map2_id == 0, "map2_id", "failed to get ID 2\n");
 104
 105 cleanup:
 106         test_btf_map_in_map__destroy(skel);
 107 }
 108
 109 static void test_diff_size(void)
 110 {
 111         struct test_btf_map_in_map *skel;
 112         int err, inner_map_fd, zero = 0;
 113
 114         skel = test_btf_map_in_map__open_and_load();
 115         if (CHECK(!skel, "skel_open", "failed to open&load skeleton\n"))
 116                 return;
 117
 118         inner_map_fd = bpf_map__fd(skel->maps.sockarr_sz2);
 119         err = bpf_map_update_elem(bpf_map__fd(skel->maps.outer_sockarr), &zero,
 120                                   &inner_map_fd, 0);
 121         CHECK(err, "outer_sockarr inner map size check",
 122               "cannot use a different size inner_map\n");
 123
 124         inner_map_fd = bpf_map__fd(skel->maps.inner_map_sz2);
 125         err = bpf_map_update_elem(bpf_map__fd(skel->maps.outer_arr), &zero,
 126                                   &inner_map_fd, 0);
 127         CHECK(!err, "outer_arr inner map size check",
 128               "incorrectly updated with a different size inner_map\n");
 129
 130         test_btf_map_in_map__destroy(skel);
 131 }
 132
 133 void test_btf_map_in_map(void)
 134 {
 135         if (test__start_subtest("lookup_update"))
 136                 test_lookup_update();
 137
 138         if (test__start_subtest("diff_size"))
 139                 test_diff_size();
 140 }