1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2025 Meta Platforms, Inc. and affiliates. */ 3 #include <test_progs.h> 4 #include "cgroup_helpers.h" 5 #include "cgroup_preorder.skel.h" 6 7 static int run_getsockopt_test(int cg_parent, int cg_child, int sock_fd, bool all_preorder) 8 { 9 LIBBPF_OPTS(bpf_prog_attach_opts, opts); 10 enum bpf_attach_type prog_c_atype, prog_c2_atype, prog_p_atype, prog_p2_atype; 11 int prog_c_fd, prog_c2_fd, prog_p_fd, prog_p2_fd; 12 struct cgroup_preorder *skel = NULL; 13 struct bpf_program *prog; 14 __u8 *result, buf; 15 socklen_t optlen; 16 int err = 0; 17 18 skel = cgroup_preorder__open_and_load(); 19 if (!ASSERT_OK_PTR(skel, "cgroup_preorder__open_and_load")) 20 return 0; 21 22 buf = 0x00; 23 err = setsockopt(sock_fd, SOL_IP, IP_TOS, &buf, 1); 24 if (!ASSERT_OK(err, "setsockopt")) 25 goto close_skel; 26 27 opts.flags = BPF_F_ALLOW_MULTI; 28 if (all_preorder) 29 opts.flags |= BPF_F_PREORDER; 30 prog = skel->progs.child; 31 prog_c_fd = bpf_program__fd(prog); 32 prog_c_atype = bpf_program__expected_attach_type(prog); 33 err = bpf_prog_attach_opts(prog_c_fd, cg_child, prog_c_atype, &opts); 34 if (!ASSERT_OK(err, "bpf_prog_attach_opts-child")) 35 goto close_skel; 36 37 opts.flags = BPF_F_ALLOW_MULTI | BPF_F_PREORDER; 38 prog = skel->progs.child_2; 39 prog_c2_fd = bpf_program__fd(prog); 40 prog_c2_atype = bpf_program__expected_attach_type(prog); 41 err = bpf_prog_attach_opts(prog_c2_fd, cg_child, prog_c2_atype, &opts); 42 if (!ASSERT_OK(err, "bpf_prog_attach_opts-child_2")) 43 goto detach_child; 44 45 optlen = 1; 46 err = getsockopt(sock_fd, SOL_IP, IP_TOS, &buf, &optlen); 47 if (!ASSERT_OK(err, "getsockopt")) 48 goto detach_child_2; 49 50 result = skel->bss->result; 51 if (all_preorder) 52 ASSERT_TRUE(result[0] == 1 && result[1] == 2, "child only"); 53 else 54 ASSERT_TRUE(result[0] == 2 && result[1] == 1, "child only"); 55 56 skel->bss->idx = 0; 57 memset(result, 0, 4); 58 59 opts.flags = BPF_F_ALLOW_MULTI; 60 if (all_preorder) 61 opts.flags |= BPF_F_PREORDER; 62 prog = skel->progs.parent; 63 prog_p_fd = bpf_program__fd(prog); 64 prog_p_atype = bpf_program__expected_attach_type(prog); 65 err = bpf_prog_attach_opts(prog_p_fd, cg_parent, prog_p_atype, &opts); 66 if (!ASSERT_OK(err, "bpf_prog_attach_opts-parent")) 67 goto detach_child_2; 68 69 opts.flags = BPF_F_ALLOW_MULTI | BPF_F_PREORDER; 70 prog = skel->progs.parent_2; 71 prog_p2_fd = bpf_program__fd(prog); 72 prog_p2_atype = bpf_program__expected_attach_type(prog); 73 err = bpf_prog_attach_opts(prog_p2_fd, cg_parent, prog_p2_atype, &opts); 74 if (!ASSERT_OK(err, "bpf_prog_attach_opts-parent_2")) 75 goto detach_parent; 76 77 err = getsockopt(sock_fd, SOL_IP, IP_TOS, &buf, &optlen); 78 if (!ASSERT_OK(err, "getsockopt")) 79 goto detach_parent_2; 80 81 if (all_preorder) 82 ASSERT_TRUE(result[0] == 3 && result[1] == 4 && result[2] == 1 && result[3] == 2, 83 "parent and child"); 84 else 85 ASSERT_TRUE(result[0] == 4 && result[1] == 2 && result[2] == 1 && result[3] == 3, 86 "parent and child"); 87 88 detach_parent_2: 89 ASSERT_OK(bpf_prog_detach2(prog_p2_fd, cg_parent, prog_p2_atype), 90 "bpf_prog_detach2-parent_2"); 91 detach_parent: 92 ASSERT_OK(bpf_prog_detach2(prog_p_fd, cg_parent, prog_p_atype), 93 "bpf_prog_detach2-parent"); 94 detach_child_2: 95 ASSERT_OK(bpf_prog_detach2(prog_c2_fd, cg_child, prog_c2_atype), 96 "bpf_prog_detach2-child_2"); 97 detach_child: 98 ASSERT_OK(bpf_prog_detach2(prog_c_fd, cg_child, prog_c_atype), 99 "bpf_prog_detach2-child"); 100 close_skel: 101 cgroup_preorder__destroy(skel); 102 return err; 103 } 104 105 /* 106 * Replacing a link's program (bpf_link_update) must target the correct slot in 107 * the effective array even when a BPF_F_PREORDER program is attached to the 108 * same cgroup. All programs here are attached to a single cgroup; "parent" is 109 * reused only as a third distinct program. 110 * 111 * Attach child(1) normally and child_2(2) with BPF_F_PREORDER, so the effective 112 * order is [2, 1]. Then replace child(1)'s program with parent(3): only the 113 * non-preorder slot changes, giving [2, 3]. 114 */ 115 static int run_link_replace_test(int cgroup_fd, int sock_fd) 116 { 117 LIBBPF_OPTS(bpf_link_create_opts, create_opts); 118 int err = 0, normal_link = -1, preorder_link = -1; 119 struct cgroup_preorder *skel = NULL; 120 enum bpf_attach_type atype; 121 __u8 *result, buf = 0x00; 122 socklen_t optlen = 1; 123 124 skel = cgroup_preorder__open_and_load(); 125 if (!ASSERT_OK_PTR(skel, "cgroup_preorder__open_and_load")) 126 return -1; 127 128 err = setsockopt(sock_fd, SOL_IP, IP_TOS, &buf, 1); 129 if (!ASSERT_OK(err, "setsockopt")) 130 goto close_skel; 131 132 atype = bpf_program__expected_attach_type(skel->progs.child); 133 134 create_opts.flags = 0; 135 normal_link = bpf_link_create(bpf_program__fd(skel->progs.child), 136 cgroup_fd, atype, &create_opts); 137 if (!ASSERT_GE(normal_link, 0, "create_normal_link")) { 138 err = normal_link; 139 goto close_skel; 140 } 141 142 create_opts.flags = BPF_F_PREORDER; 143 preorder_link = bpf_link_create(bpf_program__fd(skel->progs.child_2), 144 cgroup_fd, atype, &create_opts); 145 if (!ASSERT_GE(preorder_link, 0, "create_preorder_link")) { 146 err = preorder_link; 147 goto close_links; 148 } 149 150 result = skel->bss->result; 151 skel->bss->idx = 0; 152 memset(result, 0, 4); 153 154 err = getsockopt(sock_fd, SOL_IP, IP_TOS, &buf, &optlen); 155 if (!ASSERT_OK(err, "getsockopt-before")) 156 goto close_links; 157 ASSERT_TRUE(result[0] == 2 && result[1] == 1, "order before update"); 158 159 /* Replace the normal link's program child(1) -> parent(3). */ 160 err = bpf_link_update(normal_link, bpf_program__fd(skel->progs.parent), NULL); 161 if (!ASSERT_OK(err, "bpf_link_update")) 162 goto close_links; 163 164 skel->bss->idx = 0; 165 memset(result, 0, 4); 166 167 err = getsockopt(sock_fd, SOL_IP, IP_TOS, &buf, &optlen); 168 if (!ASSERT_OK(err, "getsockopt-after")) 169 goto close_links; 170 ASSERT_TRUE(result[0] == 2 && result[1] == 3, "order after update"); 171 172 close_links: 173 if (preorder_link >= 0) 174 close(preorder_link); 175 close(normal_link); 176 close_skel: 177 cgroup_preorder__destroy(skel); 178 return err; 179 } 180 181 void test_cgroup_preorder(void) 182 { 183 int cg_parent = -1, cg_child = -1, sock_fd = -1; 184 185 cg_parent = test__join_cgroup("/parent"); 186 if (!ASSERT_GE(cg_parent, 0, "join_cgroup /parent")) 187 goto out; 188 189 cg_child = test__join_cgroup("/parent/child"); 190 if (!ASSERT_GE(cg_child, 0, "join_cgroup /parent/child")) 191 goto out; 192 193 sock_fd = socket(AF_INET, SOCK_STREAM, 0); 194 if (!ASSERT_GE(sock_fd, 0, "socket")) 195 goto out; 196 197 ASSERT_OK(run_getsockopt_test(cg_parent, cg_child, sock_fd, false), "getsockopt_test_1"); 198 ASSERT_OK(run_getsockopt_test(cg_parent, cg_child, sock_fd, true), "getsockopt_test_2"); 199 ASSERT_OK(run_link_replace_test(cg_child, sock_fd), "link_replace_test"); 200 201 out: 202 close(sock_fd); 203 close(cg_child); 204 close(cg_parent); 205 } 206