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 9 static unsigned int duration; 10 11 static void test_hash_map(void) 12 { 13 int i, err, max_entries; 14 struct for_each_hash_map_elem *skel; 15 __u64 *percpu_valbuf = NULL; 16 size_t percpu_val_sz; 17 __u32 key, num_cpus; 18 __u64 val; 19 LIBBPF_OPTS(bpf_test_run_opts, topts, 20 .data_in = &pkt_v4, 21 .data_size_in = sizeof(pkt_v4), 22 .repeat = 1, 23 ); 24 25 skel = for_each_hash_map_elem__open_and_load(); 26 if (!ASSERT_OK_PTR(skel, "for_each_hash_map_elem__open_and_load")) 27 return; 28 29 max_entries = bpf_map__max_entries(skel->maps.hashmap); 30 for (i = 0; i < max_entries; i++) { 31 key = i; 32 val = i + 1; 33 err = bpf_map__update_elem(skel->maps.hashmap, &key, sizeof(key), 34 &val, sizeof(val), BPF_ANY); 35 if (!ASSERT_OK(err, "map_update")) 36 goto out; 37 } 38 39 num_cpus = bpf_num_possible_cpus(); 40 percpu_val_sz = sizeof(__u64) * num_cpus; 41 percpu_valbuf = malloc(percpu_val_sz); 42 if (!ASSERT_OK_PTR(percpu_valbuf, "percpu_valbuf")) 43 goto out; 44 45 key = 1; 46 for (i = 0; i < num_cpus; i++) 47 percpu_valbuf[i] = i + 1; 48 err = bpf_map__update_elem(skel->maps.percpu_map, &key, sizeof(key), 49 percpu_valbuf, percpu_val_sz, BPF_ANY); 50 if (!ASSERT_OK(err, "percpu_map_update")) 51 goto out; 52 53 err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_pkt_access), &topts); 54 duration = topts.duration; 55 if (CHECK(err || topts.retval, "ipv4", "err %d errno %d retval %d\n", 56 err, errno, topts.retval)) 57 goto out; 58 59 ASSERT_EQ(skel->bss->hashmap_output, 4, "hashmap_output"); 60 ASSERT_EQ(skel->bss->hashmap_elems, max_entries, "hashmap_elems"); 61 62 key = 1; 63 err = bpf_map__lookup_elem(skel->maps.hashmap, &key, sizeof(key), &val, sizeof(val), 0); 64 ASSERT_ERR(err, "hashmap_lookup"); 65 66 ASSERT_EQ(skel->bss->percpu_called, 1, "percpu_called"); 67 ASSERT_LT(skel->bss->cpu, num_cpus, "num_cpus"); 68 ASSERT_EQ(skel->bss->percpu_map_elems, 1, "percpu_map_elems"); 69 ASSERT_EQ(skel->bss->percpu_key, 1, "percpu_key"); 70 ASSERT_EQ(skel->bss->percpu_val, skel->bss->cpu + 1, "percpu_val"); 71 ASSERT_EQ(skel->bss->percpu_output, 100, "percpu_output"); 72 out: 73 free(percpu_valbuf); 74 for_each_hash_map_elem__destroy(skel); 75 } 76 77 static void test_array_map(void) 78 { 79 __u32 key, num_cpus, max_entries; 80 int i, err; 81 struct for_each_array_map_elem *skel; 82 __u64 *percpu_valbuf = NULL; 83 size_t percpu_val_sz; 84 __u64 val, expected_total; 85 LIBBPF_OPTS(bpf_test_run_opts, topts, 86 .data_in = &pkt_v4, 87 .data_size_in = sizeof(pkt_v4), 88 .repeat = 1, 89 ); 90 91 skel = for_each_array_map_elem__open_and_load(); 92 if (!ASSERT_OK_PTR(skel, "for_each_array_map_elem__open_and_load")) 93 return; 94 95 expected_total = 0; 96 max_entries = bpf_map__max_entries(skel->maps.arraymap); 97 for (i = 0; i < max_entries; i++) { 98 key = i; 99 val = i + 1; 100 /* skip the last iteration for expected total */ 101 if (i != max_entries - 1) 102 expected_total += val; 103 err = bpf_map__update_elem(skel->maps.arraymap, &key, sizeof(key), 104 &val, sizeof(val), BPF_ANY); 105 if (!ASSERT_OK(err, "map_update")) 106 goto out; 107 } 108 109 num_cpus = bpf_num_possible_cpus(); 110 percpu_val_sz = sizeof(__u64) * num_cpus; 111 percpu_valbuf = malloc(percpu_val_sz); 112 if (!ASSERT_OK_PTR(percpu_valbuf, "percpu_valbuf")) 113 goto out; 114 115 key = 0; 116 for (i = 0; i < num_cpus; i++) 117 percpu_valbuf[i] = i + 1; 118 err = bpf_map__update_elem(skel->maps.percpu_map, &key, sizeof(key), 119 percpu_valbuf, percpu_val_sz, BPF_ANY); 120 if (!ASSERT_OK(err, "percpu_map_update")) 121 goto out; 122 123 err = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.test_pkt_access), &topts); 124 duration = topts.duration; 125 if (CHECK(err || topts.retval, "ipv4", "err %d errno %d retval %d\n", 126 err, errno, topts.retval)) 127 goto out; 128 129 ASSERT_EQ(skel->bss->arraymap_output, expected_total, "array_output"); 130 ASSERT_EQ(skel->bss->cpu + 1, skel->bss->percpu_val, "percpu_val"); 131 132 out: 133 free(percpu_valbuf); 134 for_each_array_map_elem__destroy(skel); 135 } 136 137 static void test_write_map_key(void) 138 { 139 struct for_each_map_elem_write_key *skel; 140 141 skel = for_each_map_elem_write_key__open_and_load(); 142 if (!ASSERT_ERR_PTR(skel, "for_each_map_elem_write_key__open_and_load")) 143 for_each_map_elem_write_key__destroy(skel); 144 } 145 146 void test_for_each(void) 147 { 148 if (test__start_subtest("hash_map")) 149 test_hash_map(); 150 if (test__start_subtest("array_map")) 151 test_array_map(); 152 if (test__start_subtest("write_map_key")) 153 test_write_map_key(); 154 } 155