1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2022 Meta Platforms, Inc. and affiliates. */ 3 4 #include <test_progs.h> 5 #include <network_helpers.h> 6 7 #include "rbtree.skel.h" 8 #include "rbtree_fail.skel.h" 9 #include "rbtree_btf_fail__wrong_node_type.skel.h" 10 #include "rbtree_btf_fail__add_wrong_type.skel.h" 11 #include "rbtree_search.skel.h" 12 13 static void test_rbtree_add_nodes(void) 14 { 15 LIBBPF_OPTS(bpf_test_run_opts, opts, 16 .data_in = &pkt_v4, 17 .data_size_in = sizeof(pkt_v4), 18 .repeat = 1, 19 ); 20 struct rbtree *skel; 21 int ret; 22 23 skel = rbtree__open_and_load(); 24 if (!ASSERT_OK_PTR(skel, "rbtree__open_and_load")) 25 return; 26 27 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.rbtree_add_nodes), &opts); 28 ASSERT_OK(ret, "rbtree_add_nodes run"); 29 ASSERT_OK(opts.retval, "rbtree_add_nodes retval"); 30 ASSERT_EQ(skel->data->less_callback_ran, 1, "rbtree_add_nodes less_callback_ran"); 31 32 rbtree__destroy(skel); 33 } 34 35 static void test_rbtree_add_nodes_nested(void) 36 { 37 LIBBPF_OPTS(bpf_test_run_opts, opts, 38 .data_in = &pkt_v4, 39 .data_size_in = sizeof(pkt_v4), 40 .repeat = 1, 41 ); 42 struct rbtree *skel; 43 int ret; 44 45 skel = rbtree__open_and_load(); 46 if (!ASSERT_OK_PTR(skel, "rbtree__open_and_load")) 47 return; 48 49 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.rbtree_add_nodes_nested), &opts); 50 ASSERT_OK(ret, "rbtree_add_nodes_nested run"); 51 ASSERT_OK(opts.retval, "rbtree_add_nodes_nested retval"); 52 ASSERT_EQ(skel->data->less_callback_ran, 1, "rbtree_add_nodes_nested less_callback_ran"); 53 54 rbtree__destroy(skel); 55 } 56 57 static void test_rbtree_add_and_remove(void) 58 { 59 LIBBPF_OPTS(bpf_test_run_opts, opts, 60 .data_in = &pkt_v4, 61 .data_size_in = sizeof(pkt_v4), 62 .repeat = 1, 63 ); 64 struct rbtree *skel; 65 int ret; 66 67 skel = rbtree__open_and_load(); 68 if (!ASSERT_OK_PTR(skel, "rbtree__open_and_load")) 69 return; 70 71 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.rbtree_add_and_remove), &opts); 72 ASSERT_OK(ret, "rbtree_add_and_remove"); 73 ASSERT_OK(opts.retval, "rbtree_add_and_remove retval"); 74 ASSERT_EQ(skel->data->removed_key, 5, "rbtree_add_and_remove first removed key"); 75 76 rbtree__destroy(skel); 77 } 78 79 static void test_rbtree_add_and_remove_array(void) 80 { 81 LIBBPF_OPTS(bpf_test_run_opts, opts, 82 .data_in = &pkt_v4, 83 .data_size_in = sizeof(pkt_v4), 84 .repeat = 1, 85 ); 86 struct rbtree *skel; 87 int ret; 88 89 skel = rbtree__open_and_load(); 90 if (!ASSERT_OK_PTR(skel, "rbtree__open_and_load")) 91 return; 92 93 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.rbtree_add_and_remove_array), &opts); 94 ASSERT_OK(ret, "rbtree_add_and_remove_array"); 95 ASSERT_OK(opts.retval, "rbtree_add_and_remove_array retval"); 96 97 rbtree__destroy(skel); 98 } 99 100 static void test_rbtree_first_and_remove(void) 101 { 102 LIBBPF_OPTS(bpf_test_run_opts, opts, 103 .data_in = &pkt_v4, 104 .data_size_in = sizeof(pkt_v4), 105 .repeat = 1, 106 ); 107 struct rbtree *skel; 108 int ret; 109 110 skel = rbtree__open_and_load(); 111 if (!ASSERT_OK_PTR(skel, "rbtree__open_and_load")) 112 return; 113 114 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.rbtree_first_and_remove), &opts); 115 ASSERT_OK(ret, "rbtree_first_and_remove"); 116 ASSERT_OK(opts.retval, "rbtree_first_and_remove retval"); 117 ASSERT_EQ(skel->data->first_data[0], 2, "rbtree_first_and_remove first rbtree_first()"); 118 ASSERT_EQ(skel->data->removed_key, 1, "rbtree_first_and_remove first removed key"); 119 ASSERT_EQ(skel->data->first_data[1], 4, "rbtree_first_and_remove second rbtree_first()"); 120 121 rbtree__destroy(skel); 122 } 123 124 static void test_rbtree_api_release_aliasing(void) 125 { 126 LIBBPF_OPTS(bpf_test_run_opts, opts, 127 .data_in = &pkt_v4, 128 .data_size_in = sizeof(pkt_v4), 129 .repeat = 1, 130 ); 131 struct rbtree *skel; 132 int ret; 133 134 skel = rbtree__open_and_load(); 135 if (!ASSERT_OK_PTR(skel, "rbtree__open_and_load")) 136 return; 137 138 ret = bpf_prog_test_run_opts(bpf_program__fd(skel->progs.rbtree_api_release_aliasing), &opts); 139 ASSERT_OK(ret, "rbtree_api_release_aliasing"); 140 ASSERT_OK(opts.retval, "rbtree_api_release_aliasing retval"); 141 ASSERT_EQ(skel->data->first_data[0], 42, "rbtree_api_release_aliasing first rbtree_remove()"); 142 ASSERT_EQ(skel->data->first_data[1], -1, "rbtree_api_release_aliasing second rbtree_remove()"); 143 144 rbtree__destroy(skel); 145 } 146 147 void test_rbtree_success(void) 148 { 149 if (test__start_subtest("rbtree_add_nodes")) 150 test_rbtree_add_nodes(); 151 if (test__start_subtest("rbtree_add_nodes_nested")) 152 test_rbtree_add_nodes_nested(); 153 if (test__start_subtest("rbtree_add_and_remove")) 154 test_rbtree_add_and_remove(); 155 if (test__start_subtest("rbtree_add_and_remove_array")) 156 test_rbtree_add_and_remove_array(); 157 if (test__start_subtest("rbtree_first_and_remove")) 158 test_rbtree_first_and_remove(); 159 if (test__start_subtest("rbtree_api_release_aliasing")) 160 test_rbtree_api_release_aliasing(); 161 } 162 163 #define BTF_FAIL_TEST(suffix) \ 164 void test_rbtree_btf_fail__##suffix(void) \ 165 { \ 166 struct rbtree_btf_fail__##suffix *skel; \ 167 \ 168 skel = rbtree_btf_fail__##suffix##__open_and_load(); \ 169 if (!ASSERT_ERR_PTR(skel, \ 170 "rbtree_btf_fail__" #suffix "__open_and_load unexpected success")) \ 171 rbtree_btf_fail__##suffix##__destroy(skel); \ 172 } 173 174 #define RUN_BTF_FAIL_TEST(suffix) \ 175 if (test__start_subtest("rbtree_btf_fail__" #suffix)) \ 176 test_rbtree_btf_fail__##suffix(); 177 178 BTF_FAIL_TEST(wrong_node_type); 179 BTF_FAIL_TEST(add_wrong_type); 180 181 void test_rbtree_btf_fail(void) 182 { 183 RUN_BTF_FAIL_TEST(wrong_node_type); 184 RUN_BTF_FAIL_TEST(add_wrong_type); 185 } 186 187 void test_rbtree_fail(void) 188 { 189 RUN_TESTS(rbtree_fail); 190 } 191 192 void test_rbtree_search(void) 193 { 194 RUN_TESTS(rbtree_search); 195 } 196