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

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2021 Facebook */
   3 #include <test_progs.h>
   4 #include <network_helpers.h>
   5 #include "for_each_hash_map_elem.skel.h"
   6 #include "for_each_array_map_elem.skel.h"
   7 #include "for_each_map_elem_write_key.skel.h"
   8 #include "for_each_multi_maps.skel.h"
   9
  10 static unsigned int duration;
  11
  12 static void test_hash_map(void)
  13 {
  14         int i, err, max_entries;
  15         struct for_each_hash_map_elem *skel;
  16         __u64 *percpu_valbuf = NULL;
  17         size_t percpu_val_sz;
  18         __u32 key, num_cpus;
  19         __u64 val;
  20         LIBBPF_OPTS(bpf_test_run_opts, topts,
  21                 .data_in = &pkt_v4,
  22                 .data_size_in = sizeof(pkt_v4),
  23                 .repeat = 1,
  24         );
  25
  26         skel = for_each_hash_map_elem__open_and_load();
  27         if (!ASSERT_OK_PTR(skel, "for_each_hash_map_elem__open_and_load"))
  28                 return;
  29
  30         max_entries = bpf_map__max_entries(skel->maps.hashmap);
  31         for (i = 0; i < max_entries; i++) {
  32                 key = i;
  33                 val = i + 1;
  34                 err = bpf_map__update_elem(skel->maps.hashmap, &key, sizeof(key),
  35                                            &val, sizeof(val), BPF_ANY);
  36                 if (!ASSERT_OK(err, "map_update"))
  37                         goto out;
  38         }
  39
  40         num_cpus = bpf_num_possible_cpus();
  41         percpu_val_sz = sizeof(__u64) * num_cpus;
  42         percpu_valbuf = malloc(percpu_val_sz);
  43         if (!ASSERT_OK_PTR(percpu_valbuf, "percpu_valbuf"))
  44                 goto out;
  45
  46         key = 1;
  47         for (i = 0; i < num_cpus; i++)
  48                 percpu_valbuf[i] = i + 1;
  49         err = bpf_map__update_elem(skel->maps.percpu_map, &key, sizeof(key),
  50                                    percpu_valbuf, percpu_val_sz, BPF_ANY);
  51         if (!ASSERT_OK(err, "percpu_map_update"))
  52                 goto out;
  53
  54         err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_pkt_access), &topts);
  55         duration = topts.duration;
  56         if (CHECK(err || topts.retval, "ipv4", "err %d errno %d retval %d\n",
  57                   err, errno, topts.retval))
  58                 goto out;
  59
  60         ASSERT_EQ(skel->bss->hashmap_output, 4, "hashmap_output");
  61         ASSERT_EQ(skel->bss->hashmap_elems, max_entries, "hashmap_elems");
  62
  63         key = 1;
  64         err = bpf_map__lookup_elem(skel->maps.hashmap, &key, sizeof(key), &val, sizeof(val), 0);
  65         ASSERT_ERR(err, "hashmap_lookup");
  66
  67         ASSERT_EQ(skel->bss->percpu_called, 1, "percpu_called");
  68         ASSERT_LT(skel->bss->cpu, num_cpus, "num_cpus");
  69         ASSERT_EQ(skel->bss->percpu_map_elems, 1, "percpu_map_elems");
  70         ASSERT_EQ(skel->bss->percpu_key, 1, "percpu_key");
  71         ASSERT_EQ(skel->bss->percpu_val, skel->bss->cpu + 1, "percpu_val");
  72         ASSERT_EQ(skel->bss->percpu_output, 100, "percpu_output");
  73 out:
  74         free(percpu_valbuf);
  75         for_each_hash_map_elem__destroy(skel);
  76 }
  77
  78 static void test_array_map(void)
  79 {
  80         __u32 key, num_cpus, max_entries;
  81         int i, err;
  82         struct for_each_array_map_elem *skel;
  83         __u64 *percpu_valbuf = NULL;
  84         size_t percpu_val_sz;
  85         __u64 val, expected_total;
  86         LIBBPF_OPTS(bpf_test_run_opts, topts,
  87                 .data_in = &pkt_v4,
  88                 .data_size_in = sizeof(pkt_v4),
  89                 .repeat = 1,
  90         );
  91
  92         skel = for_each_array_map_elem__open_and_load();
  93         if (!ASSERT_OK_PTR(skel, "for_each_array_map_elem__open_and_load"))
  94                 return;
  95
  96         expected_total = 0;
  97         max_entries = bpf_map__max_entries(skel->maps.arraymap);
  98         for (i = 0; i < max_entries; i++) {
  99                 key = i;
 100                 val = i + 1;
 101                 /* skip the last iteration for expected total */
 102                 if (i != max_entries - 1)
 103                         expected_total += val;
 104                 err = bpf_map__update_elem(skel->maps.arraymap, &key, sizeof(key),
 105                                            &val, sizeof(val), BPF_ANY);
 106                 if (!ASSERT_OK(err, "map_update"))
 107                         goto out;
 108         }
 109
 110         num_cpus = bpf_num_possible_cpus();
 111         percpu_val_sz = sizeof(__u64) * num_cpus;
 112         percpu_valbuf = malloc(percpu_val_sz);
 113         if (!ASSERT_OK_PTR(percpu_valbuf, "percpu_valbuf"))
 114                 goto out;
 115
 116         key = 0;
 117         for (i = 0; i < num_cpus; i++)
 118                 percpu_valbuf[i] = i + 1;
 119         err = bpf_map__update_elem(skel->maps.percpu_map, &key, sizeof(key),
 120                                    percpu_valbuf, percpu_val_sz, BPF_ANY);
 121         if (!ASSERT_OK(err, "percpu_map_update"))
 122                 goto out;
 123
 124         err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_pkt_access), &topts);
 125         duration = topts.duration;
 126         if (CHECK(err || topts.retval, "ipv4", "err %d errno %d retval %d\n",
 127                   err, errno, topts.retval))
 128                 goto out;
 129
 130         ASSERT_EQ(skel->bss->arraymap_output, expected_total, "array_output");
 131         ASSERT_EQ(skel->bss->cpu + 1, skel->bss->percpu_val, "percpu_val");
 132
 133 out:
 134         free(percpu_valbuf);
 135         for_each_array_map_elem__destroy(skel);
 136 }
 137
 138 static void test_write_map_key(void)
 139 {
 140         struct for_each_map_elem_write_key *skel;
 141
 142         skel = for_each_map_elem_write_key__open_and_load();
 143         if (!ASSERT_ERR_PTR(skel, "for_each_map_elem_write_key__open_and_load"))
 144                 for_each_map_elem_write_key__destroy(skel);
 145 }
 146
 147 static void test_multi_maps(void)
 148 {
 149         struct for_each_multi_maps *skel;
 150         __u64 val, array_total, hash_total;
 151         __u32 key, max_entries;
 152         int i, err;
 153
 154         LIBBPF_OPTS(bpf_test_run_opts, topts,
 155                 .data_in = &pkt_v4,
 156                 .data_size_in = sizeof(pkt_v4),
 157                 .repeat = 1,
 158         );
 159
 160         skel = for_each_multi_maps__open_and_load();
 161         if (!ASSERT_OK_PTR(skel, "for_each_multi_maps__open_and_load"))
 162                 return;
 163
 164         array_total = 0;
 165         max_entries = bpf_map__max_entries(skel->maps.arraymap);
 166         for (i = 0; i < max_entries; i++) {
 167                 key = i;
 168                 val = i + 1;
 169                 array_total += val;
 170                 err = bpf_map__update_elem(skel->maps.arraymap, &key, sizeof(key),
 171                                            &val, sizeof(val), BPF_ANY);
 172                 if (!ASSERT_OK(err, "array_map_update"))
 173                         goto out;
 174         }
 175
 176         hash_total = 0;
 177         max_entries = bpf_map__max_entries(skel->maps.hashmap);
 178         for (i = 0; i < max_entries; i++) {
 179                 key = i + 100;
 180                 val = i + 1;
 181                 hash_total += val;
 182                 err = bpf_map__update_elem(skel->maps.hashmap, &key, sizeof(key),
 183                                            &val, sizeof(val), BPF_ANY);
 184                 if (!ASSERT_OK(err, "hash_map_update"))
 185                         goto out;
 186         }
 187
 188         skel->bss->data_output = 0;
 189         skel->bss->use_array = 1;
 190         err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_pkt_access), &topts);
 191         ASSERT_OK(err, "bpf_prog_test_run_opts");
 192         ASSERT_OK(topts.retval, "retval");
 193         ASSERT_EQ(skel->bss->data_output, array_total, "array output");
 194
 195         skel->bss->data_output = 0;
 196         skel->bss->use_array = 0;
 197         err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_pkt_access), &topts);
 198         ASSERT_OK(err, "bpf_prog_test_run_opts");
 199         ASSERT_OK(topts.retval, "retval");
 200         ASSERT_EQ(skel->bss->data_output, hash_total, "hash output");
 201
 202 out:
 203         for_each_multi_maps__destroy(skel);
 204 }
 205
 206 void test_for_each(void)
 207 {
 208         if (test__start_subtest("hash_map"))
 209                 test_hash_map();
 210         if (test__start_subtest("array_map"))
 211                 test_array_map();
 212         if (test__start_subtest("write_map_key"))
 213                 test_write_map_key();
 214         if (test__start_subtest("multi_maps"))
 215                 test_multi_maps();
 216 }