1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 2 3 /* 4 * End-to-end eBPF tunnel test suite 5 * The file tests BPF network tunnel implementation. 6 * 7 * Topology: 8 * --------- 9 * root namespace | at_ns0 namespace 10 * | 11 * ----------- | ----------- 12 * | tnl dev | | | tnl dev | (overlay network) 13 * ----------- | ----------- 14 * metadata-mode | metadata-mode 15 * with bpf | with bpf 16 * | 17 * ---------- | ---------- 18 * | veth1 | --------- | veth0 | (underlay network) 19 * ---------- peer ---------- 20 * 21 * 22 * Device Configuration 23 * -------------------- 24 * root namespace with metadata-mode tunnel + BPF 25 * Device names and addresses: 26 * veth1 IP 1: 172.16.1.200, IPv6: 00::22 (underlay) 27 * IP 2: 172.16.1.20, IPv6: 00::bb (underlay) 28 * tunnel dev <type>11, ex: gre11, IPv4: 10.1.1.200, IPv6: 1::22 (overlay) 29 * 30 * Namespace at_ns0 with native tunnel 31 * Device names and addresses: 32 * veth0 IPv4: 172.16.1.100, IPv6: 00::11 (underlay) 33 * tunnel dev <type>00, ex: gre00, IPv4: 10.1.1.100, IPv6: 1::11 (overlay) 34 * 35 * 36 * End-to-end ping packet flow 37 * --------------------------- 38 * Most of the tests start by namespace creation, device configuration, 39 * then ping the underlay and overlay network. When doing 'ping 10.1.1.100' 40 * from root namespace, the following operations happen: 41 * 1) Route lookup shows 10.1.1.100/24 belongs to tnl dev, fwd to tnl dev. 42 * 2) Tnl device's egress BPF program is triggered and set the tunnel metadata, 43 * with local_ip=172.16.1.200, remote_ip=172.16.1.100. BPF program choose 44 * the primary or secondary ip of veth1 as the local ip of tunnel. The 45 * choice is made based on the value of bpf map local_ip_map. 46 * 3) Outer tunnel header is prepended and route the packet to veth1's egress. 47 * 4) veth0's ingress queue receive the tunneled packet at namespace at_ns0. 48 * 5) Tunnel protocol handler, ex: vxlan_rcv, decap the packet. 49 * 6) Forward the packet to the overlay tnl dev. 50 */ 51 52 #include <arpa/inet.h> 53 #include <linux/if_link.h> 54 #include <linux/if_tun.h> 55 #include <linux/limits.h> 56 #include <linux/sysctl.h> 57 #include <linux/time_types.h> 58 #include <linux/net_tstamp.h> 59 #include <net/if.h> 60 #include <stdbool.h> 61 #include <stdio.h> 62 #include <sys/stat.h> 63 #include <unistd.h> 64 65 #include "test_progs.h" 66 #include "network_helpers.h" 67 #include "test_tunnel_kern.skel.h" 68 69 #define IP4_ADDR_VETH0 "172.16.1.100" 70 #define IP4_ADDR1_VETH1 "172.16.1.200" 71 #define IP4_ADDR2_VETH1 "172.16.1.20" 72 #define IP4_ADDR_TUNL_DEV0 "10.1.1.100" 73 #define IP4_ADDR_TUNL_DEV1 "10.1.1.200" 74 #define IP6_ADDR_TUNL_DEV0 "fc80::100" 75 #define IP6_ADDR_TUNL_DEV1 "fc80::200" 76 77 #define IP6_ADDR_VETH0 "::11" 78 #define IP6_ADDR1_VETH1 "::22" 79 #define IP6_ADDR2_VETH1 "::bb" 80 81 #define IP4_ADDR1_HEX_VETH1 0xac1001c8 82 #define IP4_ADDR2_HEX_VETH1 0xac100114 83 #define IP6_ADDR1_HEX_VETH1 0x22 84 #define IP6_ADDR2_HEX_VETH1 0xbb 85 86 #define MAC_TUNL_DEV0 "52:54:00:d9:01:00" 87 #define MAC_TUNL_DEV1 "52:54:00:d9:02:00" 88 #define MAC_VETH1 "52:54:00:d9:03:00" 89 90 #define VXLAN_TUNL_DEV0 "vxlan00" 91 #define VXLAN_TUNL_DEV1 "vxlan11" 92 #define IP6VXLAN_TUNL_DEV0 "ip6vxlan00" 93 #define IP6VXLAN_TUNL_DEV1 "ip6vxlan11" 94 95 #define IPIP_TUNL_DEV0 "ipip00" 96 #define IPIP_TUNL_DEV1 "ipip11" 97 98 #define XFRM_AUTH "0x1111111111111111111111111111111111111111" 99 #define XFRM_ENC "0x22222222222222222222222222222222" 100 #define XFRM_SPI_IN_TO_OUT 0x1 101 #define XFRM_SPI_OUT_TO_IN 0x2 102 103 #define GRE_TUNL_DEV0 "gre00" 104 #define GRE_TUNL_DEV1 "gre11" 105 106 #define IP6GRE_TUNL_DEV0 "ip6gre00" 107 #define IP6GRE_TUNL_DEV1 "ip6gre11" 108 109 #define ERSPAN_TUNL_DEV0 "erspan00" 110 #define ERSPAN_TUNL_DEV1 "erspan11" 111 112 #define IP6ERSPAN_TUNL_DEV0 "ip6erspan00" 113 #define IP6ERSPAN_TUNL_DEV1 "ip6erspan11" 114 115 #define GENEVE_TUNL_DEV0 "geneve00" 116 #define GENEVE_TUNL_DEV1 "geneve11" 117 118 #define IP6GENEVE_TUNL_DEV0 "ip6geneve00" 119 #define IP6GENEVE_TUNL_DEV1 "ip6geneve11" 120 121 #define IP6TNL_TUNL_DEV0 "ip6tnl00" 122 #define IP6TNL_TUNL_DEV1 "ip6tnl11" 123 124 #define PING_ARGS "-i 0.01 -c 3 -w 10 -q" 125 126 static int config_device(void) 127 { 128 SYS(fail, "ip netns add at_ns0"); 129 SYS(fail, "ip link add veth0 address " MAC_VETH1 " type veth peer name veth1"); 130 SYS(fail, "ip link set veth0 netns at_ns0"); 131 SYS(fail, "ip addr add " IP4_ADDR1_VETH1 "/24 dev veth1"); 132 SYS(fail, "ip link set dev veth1 up mtu 1500"); 133 SYS(fail, "ip netns exec at_ns0 ip addr add " IP4_ADDR_VETH0 "/24 dev veth0"); 134 SYS(fail, "ip netns exec at_ns0 ip link set dev veth0 up mtu 1500"); 135 136 return 0; 137 fail: 138 return -1; 139 } 140 141 static void cleanup(void) 142 { 143 SYS_NOFAIL("test -f /var/run/netns/at_ns0 && ip netns delete at_ns0"); 144 SYS_NOFAIL("ip link del veth1"); 145 SYS_NOFAIL("ip link del %s", VXLAN_TUNL_DEV1); 146 SYS_NOFAIL("ip link del %s", IP6VXLAN_TUNL_DEV1); 147 } 148 149 static int add_vxlan_tunnel(void) 150 { 151 /* at_ns0 namespace */ 152 SYS(fail, "ip netns exec at_ns0 ip link add dev %s type vxlan external gbp dstport 4789", 153 VXLAN_TUNL_DEV0); 154 SYS(fail, "ip netns exec at_ns0 ip link set dev %s address %s up", 155 VXLAN_TUNL_DEV0, MAC_TUNL_DEV0); 156 SYS(fail, "ip netns exec at_ns0 ip addr add dev %s %s/24", 157 VXLAN_TUNL_DEV0, IP4_ADDR_TUNL_DEV0); 158 SYS(fail, "ip netns exec at_ns0 ip neigh add %s lladdr %s dev %s", 159 IP4_ADDR_TUNL_DEV1, MAC_TUNL_DEV1, VXLAN_TUNL_DEV0); 160 SYS(fail, "ip netns exec at_ns0 ip neigh add %s lladdr %s dev veth0", 161 IP4_ADDR2_VETH1, MAC_VETH1); 162 163 /* root namespace */ 164 SYS(fail, "ip link add dev %s type vxlan external gbp dstport 4789", 165 VXLAN_TUNL_DEV1); 166 SYS(fail, "ip link set dev %s address %s up", VXLAN_TUNL_DEV1, MAC_TUNL_DEV1); 167 SYS(fail, "ip addr add dev %s %s/24", VXLAN_TUNL_DEV1, IP4_ADDR_TUNL_DEV1); 168 SYS(fail, "ip neigh add %s lladdr %s dev %s", 169 IP4_ADDR_TUNL_DEV0, MAC_TUNL_DEV0, VXLAN_TUNL_DEV1); 170 171 return 0; 172 fail: 173 return -1; 174 } 175 176 static void delete_vxlan_tunnel(void) 177 { 178 SYS_NOFAIL("ip netns exec at_ns0 ip link delete dev %s", 179 VXLAN_TUNL_DEV0); 180 SYS_NOFAIL("ip link delete dev %s", VXLAN_TUNL_DEV1); 181 } 182 183 static int add_ip6vxlan_tunnel(void) 184 { 185 SYS(fail, "ip netns exec at_ns0 ip -6 addr add %s/96 dev veth0", 186 IP6_ADDR_VETH0); 187 SYS(fail, "ip netns exec at_ns0 ip link set dev veth0 up"); 188 SYS(fail, "ip -6 addr add %s/96 dev veth1", IP6_ADDR1_VETH1); 189 SYS(fail, "ip -6 addr add %s/96 dev veth1", IP6_ADDR2_VETH1); 190 SYS(fail, "ip link set dev veth1 up"); 191 192 /* at_ns0 namespace */ 193 SYS(fail, "ip netns exec at_ns0 ip link add dev %s type vxlan external dstport 4789", 194 IP6VXLAN_TUNL_DEV0); 195 SYS(fail, "ip netns exec at_ns0 ip addr add dev %s %s/24", 196 IP6VXLAN_TUNL_DEV0, IP4_ADDR_TUNL_DEV0); 197 SYS(fail, "ip netns exec at_ns0 ip link set dev %s address %s up", 198 IP6VXLAN_TUNL_DEV0, MAC_TUNL_DEV0); 199 200 /* root namespace */ 201 SYS(fail, "ip link add dev %s type vxlan external dstport 4789", 202 IP6VXLAN_TUNL_DEV1); 203 SYS(fail, "ip addr add dev %s %s/24", IP6VXLAN_TUNL_DEV1, IP4_ADDR_TUNL_DEV1); 204 SYS(fail, "ip link set dev %s address %s up", 205 IP6VXLAN_TUNL_DEV1, MAC_TUNL_DEV1); 206 207 return 0; 208 fail: 209 return -1; 210 } 211 212 static void delete_ip6vxlan_tunnel(void) 213 { 214 SYS_NOFAIL("ip netns exec at_ns0 ip -6 addr delete %s/96 dev veth0", 215 IP6_ADDR_VETH0); 216 SYS_NOFAIL("ip -6 addr delete %s/96 dev veth1", IP6_ADDR1_VETH1); 217 SYS_NOFAIL("ip -6 addr delete %s/96 dev veth1", IP6_ADDR2_VETH1); 218 SYS_NOFAIL("ip netns exec at_ns0 ip link delete dev %s", 219 IP6VXLAN_TUNL_DEV0); 220 SYS_NOFAIL("ip link delete dev %s", IP6VXLAN_TUNL_DEV1); 221 } 222 223 enum ipip_encap { 224 NONE = 0, 225 FOU = 1, 226 GUE = 2, 227 }; 228 229 static int set_ipip_encap(const char *ipproto, const char *type) 230 { 231 SYS(fail, "ip -n at_ns0 fou add port 5555 %s", ipproto); 232 SYS(fail, "ip -n at_ns0 link set dev %s type ipip encap %s", 233 IPIP_TUNL_DEV0, type); 234 SYS(fail, "ip -n at_ns0 link set dev %s type ipip encap-dport 5555", 235 IPIP_TUNL_DEV0); 236 237 return 0; 238 fail: 239 return -1; 240 } 241 242 static int set_ipv4_addr(const char *dev0, const char *dev1) 243 { 244 SYS(fail, "ip -n at_ns0 link set dev %s up", dev0); 245 SYS(fail, "ip -n at_ns0 addr add dev %s %s/24", dev0, IP4_ADDR_TUNL_DEV0); 246 SYS(fail, "ip link set dev %s up", dev1); 247 SYS(fail, "ip addr add dev %s %s/24", dev1, IP4_ADDR_TUNL_DEV1); 248 249 return 0; 250 fail: 251 return 1; 252 } 253 254 static int add_ipip_tunnel(enum ipip_encap encap) 255 { 256 int err; 257 const char *ipproto, *type; 258 259 switch (encap) { 260 case FOU: 261 ipproto = "ipproto 4"; 262 type = "fou"; 263 break; 264 case GUE: 265 ipproto = "gue"; 266 type = ipproto; 267 break; 268 default: 269 ipproto = NULL; 270 type = ipproto; 271 } 272 273 /* at_ns0 namespace */ 274 SYS(fail, "ip -n at_ns0 link add dev %s type ipip local %s remote %s", 275 IPIP_TUNL_DEV0, IP4_ADDR_VETH0, IP4_ADDR1_VETH1); 276 277 if (type && ipproto) { 278 err = set_ipip_encap(ipproto, type); 279 if (!ASSERT_OK(err, "set_ipip_encap")) 280 goto fail; 281 } 282 283 SYS(fail, "ip -n at_ns0 link set dev %s up", IPIP_TUNL_DEV0); 284 SYS(fail, "ip -n at_ns0 addr add dev %s %s/24", 285 IPIP_TUNL_DEV0, IP4_ADDR_TUNL_DEV0); 286 287 /* root namespace */ 288 if (type && ipproto) 289 SYS(fail, "ip fou add port 5555 %s", ipproto); 290 SYS(fail, "ip link add dev %s type ipip external", IPIP_TUNL_DEV1); 291 SYS(fail, "ip link set dev %s up", IPIP_TUNL_DEV1); 292 SYS(fail, "ip addr add dev %s %s/24", IPIP_TUNL_DEV1, 293 IP4_ADDR_TUNL_DEV1); 294 295 return 0; 296 fail: 297 return -1; 298 } 299 300 static void delete_ipip_tunnel(void) 301 { 302 SYS_NOFAIL("ip -n at_ns0 link delete dev %s", IPIP_TUNL_DEV0); 303 SYS_NOFAIL("ip -n at_ns0 fou del port 5555"); 304 SYS_NOFAIL("ip link delete dev %s", IPIP_TUNL_DEV1); 305 SYS_NOFAIL("ip fou del port 5555"); 306 } 307 308 static int add_xfrm_tunnel(void) 309 { 310 /* at_ns0 namespace 311 * at_ns0 -> root 312 */ 313 SYS(fail, 314 "ip netns exec at_ns0 " 315 "ip xfrm state add src %s dst %s proto esp " 316 "spi %d reqid 1 mode tunnel replay-window 42 " 317 "auth-trunc 'hmac(sha1)' %s 96 enc 'cbc(aes)' %s", 318 IP4_ADDR_VETH0, IP4_ADDR1_VETH1, XFRM_SPI_IN_TO_OUT, XFRM_AUTH, XFRM_ENC); 319 SYS(fail, 320 "ip netns exec at_ns0 " 321 "ip xfrm policy add src %s/32 dst %s/32 dir out " 322 "tmpl src %s dst %s proto esp reqid 1 " 323 "mode tunnel", 324 IP4_ADDR_TUNL_DEV0, IP4_ADDR_TUNL_DEV1, IP4_ADDR_VETH0, IP4_ADDR1_VETH1); 325 326 /* root -> at_ns0 */ 327 SYS(fail, 328 "ip netns exec at_ns0 " 329 "ip xfrm state add src %s dst %s proto esp " 330 "spi %d reqid 2 mode tunnel " 331 "auth-trunc 'hmac(sha1)' %s 96 enc 'cbc(aes)' %s", 332 IP4_ADDR1_VETH1, IP4_ADDR_VETH0, XFRM_SPI_OUT_TO_IN, XFRM_AUTH, XFRM_ENC); 333 SYS(fail, 334 "ip netns exec at_ns0 " 335 "ip xfrm policy add src %s/32 dst %s/32 dir in " 336 "tmpl src %s dst %s proto esp reqid 2 " 337 "mode tunnel", 338 IP4_ADDR_TUNL_DEV1, IP4_ADDR_TUNL_DEV0, IP4_ADDR1_VETH1, IP4_ADDR_VETH0); 339 340 /* address & route */ 341 SYS(fail, "ip netns exec at_ns0 ip addr add dev veth0 %s/32", 342 IP4_ADDR_TUNL_DEV0); 343 SYS(fail, "ip netns exec at_ns0 ip route add %s dev veth0 via %s src %s", 344 IP4_ADDR_TUNL_DEV1, IP4_ADDR1_VETH1, IP4_ADDR_TUNL_DEV0); 345 346 /* root namespace 347 * at_ns0 -> root 348 */ 349 SYS(fail, 350 "ip xfrm state add src %s dst %s proto esp " 351 "spi %d reqid 1 mode tunnel replay-window 42 " 352 "auth-trunc 'hmac(sha1)' %s 96 enc 'cbc(aes)' %s", 353 IP4_ADDR_VETH0, IP4_ADDR1_VETH1, XFRM_SPI_IN_TO_OUT, XFRM_AUTH, XFRM_ENC); 354 SYS(fail, 355 "ip xfrm policy add src %s/32 dst %s/32 dir in " 356 "tmpl src %s dst %s proto esp reqid 1 " 357 "mode tunnel", 358 IP4_ADDR_TUNL_DEV0, IP4_ADDR_TUNL_DEV1, IP4_ADDR_VETH0, IP4_ADDR1_VETH1); 359 360 /* root -> at_ns0 */ 361 SYS(fail, 362 "ip xfrm state add src %s dst %s proto esp " 363 "spi %d reqid 2 mode tunnel " 364 "auth-trunc 'hmac(sha1)' %s 96 enc 'cbc(aes)' %s", 365 IP4_ADDR1_VETH1, IP4_ADDR_VETH0, XFRM_SPI_OUT_TO_IN, XFRM_AUTH, XFRM_ENC); 366 SYS(fail, 367 "ip xfrm policy add src %s/32 dst %s/32 dir out " 368 "tmpl src %s dst %s proto esp reqid 2 " 369 "mode tunnel", 370 IP4_ADDR_TUNL_DEV1, IP4_ADDR_TUNL_DEV0, IP4_ADDR1_VETH1, IP4_ADDR_VETH0); 371 372 /* address & route */ 373 SYS(fail, "ip addr add dev veth1 %s/32", IP4_ADDR_TUNL_DEV1); 374 SYS(fail, "ip route add %s dev veth1 via %s src %s", 375 IP4_ADDR_TUNL_DEV0, IP4_ADDR_VETH0, IP4_ADDR_TUNL_DEV1); 376 377 return 0; 378 fail: 379 return -1; 380 } 381 382 static void delete_xfrm_tunnel(void) 383 { 384 SYS_NOFAIL("ip xfrm policy delete dir out src %s/32 dst %s/32", 385 IP4_ADDR_TUNL_DEV1, IP4_ADDR_TUNL_DEV0); 386 SYS_NOFAIL("ip xfrm policy delete dir in src %s/32 dst %s/32", 387 IP4_ADDR_TUNL_DEV0, IP4_ADDR_TUNL_DEV1); 388 SYS_NOFAIL("ip xfrm state delete src %s dst %s proto esp spi %d", 389 IP4_ADDR_VETH0, IP4_ADDR1_VETH1, XFRM_SPI_IN_TO_OUT); 390 SYS_NOFAIL("ip xfrm state delete src %s dst %s proto esp spi %d", 391 IP4_ADDR1_VETH1, IP4_ADDR_VETH0, XFRM_SPI_OUT_TO_IN); 392 } 393 394 static int add_ipv4_tunnel(const char *dev0, const char *dev1, 395 const char *type, const char *opt) 396 { 397 if (!type || !opt || !dev0 || !dev1) 398 return -1; 399 400 SYS(fail, "ip -n at_ns0 link add dev %s type %s %s local %s remote %s", 401 dev0, type, opt, IP4_ADDR_VETH0, IP4_ADDR1_VETH1); 402 403 SYS(fail, "ip link add dev %s type %s external", dev1, type); 404 405 return set_ipv4_addr(dev0, dev1); 406 fail: 407 return -1; 408 } 409 410 static void delete_tunnel(const char *dev0, const char *dev1) 411 { 412 if (!dev0 || !dev1) 413 return; 414 415 SYS_NOFAIL("ip netns exec at_ns0 ip link delete dev %s", dev0); 416 SYS_NOFAIL("ip link delete dev %s", dev1); 417 } 418 419 static int set_ipv6_addr(const char *dev0, const char *dev1) 420 { 421 /* disable IPv6 DAD because it might take too long and fail tests */ 422 SYS(fail, "ip -n at_ns0 addr add %s/96 dev veth0 nodad", IP6_ADDR_VETH0); 423 SYS(fail, "ip -n at_ns0 link set dev veth0 up"); 424 SYS(fail, "ip addr add %s/96 dev veth1 nodad", IP6_ADDR1_VETH1); 425 SYS(fail, "ip link set dev veth1 up"); 426 427 SYS(fail, "ip -n at_ns0 addr add dev %s %s/24", dev0, IP4_ADDR_TUNL_DEV0); 428 SYS(fail, "ip -n at_ns0 addr add dev %s %s/96 nodad", dev0, IP6_ADDR_TUNL_DEV0); 429 SYS(fail, "ip -n at_ns0 link set dev %s up", dev0); 430 431 SYS(fail, "ip addr add dev %s %s/24", dev1, IP4_ADDR_TUNL_DEV1); 432 SYS(fail, "ip addr add dev %s %s/96 nodad", dev1, IP6_ADDR_TUNL_DEV1); 433 SYS(fail, "ip link set dev %s up", dev1); 434 return 0; 435 fail: 436 return 1; 437 } 438 439 static int add_ipv6_tunnel(const char *dev0, const char *dev1, 440 const char *type, const char *opt) 441 { 442 if (!type || !opt || !dev0 || !dev1) 443 return -1; 444 445 SYS(fail, "ip -n at_ns0 link add dev %s type %s %s local %s remote %s", 446 dev0, type, opt, IP6_ADDR_VETH0, IP6_ADDR1_VETH1); 447 448 SYS(fail, "ip link add dev %s type %s external", dev1, type); 449 450 return set_ipv6_addr(dev0, dev1); 451 fail: 452 return -1; 453 } 454 455 static int add_geneve_tunnel(const char *dev0, const char *dev1, 456 const char *type, const char *opt) 457 { 458 if (!type || !opt || !dev0 || !dev1) 459 return -1; 460 461 SYS(fail, "ip -n at_ns0 link add dev %s type %s id 2 %s remote %s", 462 dev0, type, opt, IP4_ADDR1_VETH1); 463 464 SYS(fail, "ip link add dev %s type %s %s external", dev1, type, opt); 465 466 return set_ipv4_addr(dev0, dev1); 467 fail: 468 return -1; 469 } 470 471 static int add_ip6geneve_tunnel(const char *dev0, const char *dev1, 472 const char *type, const char *opt) 473 { 474 if (!type || !opt || !dev0 || !dev1) 475 return -1; 476 477 SYS(fail, "ip -n at_ns0 link add dev %s type %s id 22 %s remote %s", 478 dev0, type, opt, IP6_ADDR1_VETH1); 479 480 SYS(fail, "ip link add dev %s type %s %s external", dev1, type, opt); 481 482 return set_ipv6_addr(dev0, dev1); 483 fail: 484 return -1; 485 } 486 487 static int test_ping(int family, const char *addr) 488 { 489 SYS(fail, "%s %s %s > /dev/null", ping_command(family), PING_ARGS, addr); 490 return 0; 491 fail: 492 return -1; 493 } 494 495 static void ping_dev0(void) 496 { 497 /* ping from root namespace test */ 498 test_ping(AF_INET, IP4_ADDR_TUNL_DEV0); 499 } 500 501 static void ping_dev1(void) 502 { 503 struct nstoken *nstoken; 504 505 /* ping from at_ns0 namespace test */ 506 nstoken = open_netns("at_ns0"); 507 if (!ASSERT_OK_PTR(nstoken, "setns")) 508 return; 509 510 test_ping(AF_INET, IP4_ADDR_TUNL_DEV1); 511 close_netns(nstoken); 512 } 513 514 static void ping6_veth0(void) 515 { 516 test_ping(AF_INET6, IP6_ADDR_VETH0); 517 } 518 519 static void ping6_dev0(void) 520 { 521 test_ping(AF_INET6, IP6_ADDR_TUNL_DEV0); 522 } 523 524 static void ping6_dev1(void) 525 { 526 struct nstoken *nstoken; 527 528 /* ping from at_ns0 namespace test */ 529 nstoken = open_netns("at_ns0"); 530 if (!ASSERT_OK_PTR(nstoken, "setns")) 531 return; 532 533 test_ping(AF_INET, IP6_ADDR_TUNL_DEV1); 534 close_netns(nstoken); 535 } 536 537 static int attach_tc_prog(int ifindex, int igr_fd, int egr_fd) 538 { 539 DECLARE_LIBBPF_OPTS(bpf_tc_hook, hook, .ifindex = ifindex, 540 .attach_point = BPF_TC_INGRESS | BPF_TC_EGRESS); 541 DECLARE_LIBBPF_OPTS(bpf_tc_opts, opts1, .handle = 1, 542 .priority = 1, .prog_fd = igr_fd); 543 DECLARE_LIBBPF_OPTS(bpf_tc_opts, opts2, .handle = 1, 544 .priority = 1, .prog_fd = egr_fd); 545 int ret; 546 547 ret = bpf_tc_hook_create(&hook); 548 if (!ASSERT_OK(ret, "create tc hook")) 549 return ret; 550 551 if (igr_fd >= 0) { 552 hook.attach_point = BPF_TC_INGRESS; 553 ret = bpf_tc_attach(&hook, &opts1); 554 if (!ASSERT_OK(ret, "bpf_tc_attach")) { 555 bpf_tc_hook_destroy(&hook); 556 return ret; 557 } 558 } 559 560 if (egr_fd >= 0) { 561 hook.attach_point = BPF_TC_EGRESS; 562 ret = bpf_tc_attach(&hook, &opts2); 563 if (!ASSERT_OK(ret, "bpf_tc_attach")) { 564 bpf_tc_hook_destroy(&hook); 565 return ret; 566 } 567 } 568 569 return 0; 570 } 571 572 static int generic_attach(const char *dev, int igr_fd, int egr_fd) 573 { 574 int ifindex; 575 576 if (!ASSERT_OK_FD(igr_fd, "check ingress fd")) 577 return -1; 578 if (!ASSERT_OK_FD(egr_fd, "check egress fd")) 579 return -1; 580 581 ifindex = if_nametoindex(dev); 582 if (!ASSERT_NEQ(ifindex, 0, "get ifindex")) 583 return -1; 584 585 return attach_tc_prog(ifindex, igr_fd, egr_fd); 586 } 587 588 static int generic_attach_igr(const char *dev, int igr_fd) 589 { 590 int ifindex; 591 592 if (!ASSERT_OK_FD(igr_fd, "check ingress fd")) 593 return -1; 594 595 ifindex = if_nametoindex(dev); 596 if (!ASSERT_NEQ(ifindex, 0, "get ifindex")) 597 return -1; 598 599 return attach_tc_prog(ifindex, igr_fd, -1); 600 } 601 602 static int generic_attach_egr(const char *dev, int egr_fd) 603 { 604 int ifindex; 605 606 if (!ASSERT_OK_FD(egr_fd, "check egress fd")) 607 return -1; 608 609 ifindex = if_nametoindex(dev); 610 if (!ASSERT_NEQ(ifindex, 0, "get ifindex")) 611 return -1; 612 613 return attach_tc_prog(ifindex, -1, egr_fd); 614 } 615 616 static void test_vxlan_tunnel(void) 617 { 618 struct test_tunnel_kern *skel = NULL; 619 struct nstoken *nstoken; 620 int local_ip_map_fd = -1; 621 int set_src_prog_fd, get_src_prog_fd; 622 int set_dst_prog_fd; 623 int key = 0; 624 uint local_ip; 625 int err; 626 627 /* add vxlan tunnel */ 628 err = add_vxlan_tunnel(); 629 if (!ASSERT_OK(err, "add vxlan tunnel")) 630 goto done; 631 632 /* load and attach bpf prog to tunnel dev tc hook point */ 633 skel = test_tunnel_kern__open_and_load(); 634 if (!ASSERT_OK_PTR(skel, "test_tunnel_kern__open_and_load")) 635 goto done; 636 get_src_prog_fd = bpf_program__fd(skel->progs.vxlan_get_tunnel_src); 637 set_src_prog_fd = bpf_program__fd(skel->progs.vxlan_set_tunnel_src); 638 if (generic_attach(VXLAN_TUNL_DEV1, get_src_prog_fd, set_src_prog_fd)) 639 goto done; 640 641 /* load and attach bpf prog to veth dev tc hook point */ 642 set_dst_prog_fd = bpf_program__fd(skel->progs.veth_set_outer_dst); 643 if (generic_attach_igr("veth1", set_dst_prog_fd)) 644 goto done; 645 646 /* load and attach prog set_md to tunnel dev tc hook point at_ns0 */ 647 nstoken = open_netns("at_ns0"); 648 if (!ASSERT_OK_PTR(nstoken, "setns src")) 649 goto done; 650 set_dst_prog_fd = bpf_program__fd(skel->progs.vxlan_set_tunnel_dst); 651 if (generic_attach_egr(VXLAN_TUNL_DEV0, set_dst_prog_fd)) 652 goto done; 653 close_netns(nstoken); 654 655 /* use veth1 ip 2 as tunnel source ip */ 656 local_ip_map_fd = bpf_map__fd(skel->maps.local_ip_map); 657 if (!ASSERT_GE(local_ip_map_fd, 0, "bpf_map__fd")) 658 goto done; 659 local_ip = IP4_ADDR2_HEX_VETH1; 660 err = bpf_map_update_elem(local_ip_map_fd, &key, &local_ip, BPF_ANY); 661 if (!ASSERT_OK(err, "update bpf local_ip_map")) 662 goto done; 663 664 /* ping test */ 665 ping_dev0(); 666 667 done: 668 /* delete vxlan tunnel */ 669 delete_vxlan_tunnel(); 670 if (local_ip_map_fd >= 0) 671 close(local_ip_map_fd); 672 if (skel) 673 test_tunnel_kern__destroy(skel); 674 } 675 676 static void test_ip6vxlan_tunnel(void) 677 { 678 struct test_tunnel_kern *skel = NULL; 679 struct nstoken *nstoken; 680 int local_ip_map_fd = -1; 681 int set_src_prog_fd, get_src_prog_fd; 682 int set_dst_prog_fd; 683 int key = 0; 684 uint local_ip; 685 int err; 686 687 /* add vxlan tunnel */ 688 err = add_ip6vxlan_tunnel(); 689 if (!ASSERT_OK(err, "add_ip6vxlan_tunnel")) 690 goto done; 691 692 /* load and attach bpf prog to tunnel dev tc hook point */ 693 skel = test_tunnel_kern__open_and_load(); 694 if (!ASSERT_OK_PTR(skel, "test_tunnel_kern__open_and_load")) 695 goto done; 696 get_src_prog_fd = bpf_program__fd(skel->progs.ip6vxlan_get_tunnel_src); 697 set_src_prog_fd = bpf_program__fd(skel->progs.ip6vxlan_set_tunnel_src); 698 if (generic_attach(IP6VXLAN_TUNL_DEV1, get_src_prog_fd, set_src_prog_fd)) 699 goto done; 700 701 /* load and attach prog set_md to tunnel dev tc hook point at_ns0 */ 702 nstoken = open_netns("at_ns0"); 703 if (!ASSERT_OK_PTR(nstoken, "setns src")) 704 goto done; 705 set_dst_prog_fd = bpf_program__fd(skel->progs.ip6vxlan_set_tunnel_dst); 706 if (generic_attach_egr(IP6VXLAN_TUNL_DEV0, set_dst_prog_fd)) 707 goto done; 708 close_netns(nstoken); 709 710 /* use veth1 ip 2 as tunnel source ip */ 711 local_ip_map_fd = bpf_map__fd(skel->maps.local_ip_map); 712 if (!ASSERT_GE(local_ip_map_fd, 0, "get local_ip_map fd")) 713 goto done; 714 local_ip = IP6_ADDR2_HEX_VETH1; 715 err = bpf_map_update_elem(local_ip_map_fd, &key, &local_ip, BPF_ANY); 716 if (!ASSERT_OK(err, "update bpf local_ip_map")) 717 goto done; 718 719 /* ping test */ 720 ping_dev0(); 721 722 done: 723 /* delete ipv6 vxlan tunnel */ 724 delete_ip6vxlan_tunnel(); 725 if (local_ip_map_fd >= 0) 726 close(local_ip_map_fd); 727 if (skel) 728 test_tunnel_kern__destroy(skel); 729 } 730 731 static void test_ipip_tunnel(enum ipip_encap encap) 732 { 733 struct test_tunnel_kern *skel = NULL; 734 int set_src_prog_fd, get_src_prog_fd; 735 int err; 736 737 /* add ipip tunnel */ 738 err = add_ipip_tunnel(encap); 739 if (!ASSERT_OK(err, "add_ipip_tunnel")) 740 goto done; 741 742 /* load and attach bpf prog to tunnel dev tc hook point */ 743 skel = test_tunnel_kern__open_and_load(); 744 if (!ASSERT_OK_PTR(skel, "test_tunnel_kern__open_and_load")) 745 goto done; 746 747 switch (encap) { 748 case FOU: 749 get_src_prog_fd = bpf_program__fd( 750 skel->progs.ipip_encap_get_tunnel); 751 set_src_prog_fd = bpf_program__fd( 752 skel->progs.ipip_fou_set_tunnel); 753 break; 754 case GUE: 755 get_src_prog_fd = bpf_program__fd( 756 skel->progs.ipip_encap_get_tunnel); 757 set_src_prog_fd = bpf_program__fd( 758 skel->progs.ipip_gue_set_tunnel); 759 break; 760 default: 761 get_src_prog_fd = bpf_program__fd( 762 skel->progs.ipip_get_tunnel); 763 set_src_prog_fd = bpf_program__fd( 764 skel->progs.ipip_set_tunnel); 765 } 766 767 if (generic_attach(IPIP_TUNL_DEV1, get_src_prog_fd, set_src_prog_fd)) 768 goto done; 769 770 ping_dev0(); 771 ping_dev1(); 772 773 done: 774 /* delete ipip tunnel */ 775 delete_ipip_tunnel(); 776 if (skel) 777 test_tunnel_kern__destroy(skel); 778 } 779 780 static void test_xfrm_tunnel(void) 781 { 782 LIBBPF_OPTS(bpf_xdp_attach_opts, opts); 783 struct test_tunnel_kern *skel = NULL; 784 int xdp_prog_fd; 785 int tc_prog_fd; 786 int ifindex; 787 int err; 788 789 err = add_xfrm_tunnel(); 790 if (!ASSERT_OK(err, "add_xfrm_tunnel")) 791 return; 792 793 skel = test_tunnel_kern__open_and_load(); 794 if (!ASSERT_OK_PTR(skel, "test_tunnel_kern__open_and_load")) 795 goto done; 796 797 798 /* attach tc prog to tunnel dev */ 799 tc_prog_fd = bpf_program__fd(skel->progs.xfrm_get_state); 800 if (generic_attach_igr("veth1", tc_prog_fd)) 801 goto done; 802 803 /* attach xdp prog to tunnel dev */ 804 ifindex = if_nametoindex("veth1"); 805 if (!ASSERT_NEQ(ifindex, 0, "veth1 ifindex")) 806 goto done; 807 xdp_prog_fd = bpf_program__fd(skel->progs.xfrm_get_state_xdp); 808 if (!ASSERT_GE(xdp_prog_fd, 0, "bpf_program__fd")) 809 goto done; 810 err = bpf_xdp_attach(ifindex, xdp_prog_fd, XDP_FLAGS_REPLACE, &opts); 811 if (!ASSERT_OK(err, "bpf_xdp_attach")) 812 goto done; 813 814 ping_dev1(); 815 816 if (!ASSERT_EQ(skel->bss->xfrm_reqid, 1, "req_id")) 817 goto done; 818 if (!ASSERT_EQ(skel->bss->xfrm_spi, XFRM_SPI_IN_TO_OUT, "spi")) 819 goto done; 820 if (!ASSERT_EQ(skel->bss->xfrm_remote_ip, 0xac100164, "remote_ip")) 821 goto done; 822 if (!ASSERT_EQ(skel->bss->xfrm_replay_window, 42, "replay_window")) 823 goto done; 824 825 done: 826 delete_xfrm_tunnel(); 827 if (skel) 828 test_tunnel_kern__destroy(skel); 829 } 830 831 enum gre_test { 832 GRE, 833 GRE_NOKEY, 834 GRETAP, 835 GRETAP_NOKEY, 836 }; 837 838 static void test_gre_tunnel(enum gre_test test) 839 { 840 struct test_tunnel_kern *skel; 841 int set_fd, get_fd; 842 int err; 843 844 skel = test_tunnel_kern__open_and_load(); 845 if (!ASSERT_OK_PTR(skel, "test_tunnel_kern__open_and_load")) 846 return; 847 848 switch (test) { 849 case GRE: 850 err = add_ipv4_tunnel(GRE_TUNL_DEV0, GRE_TUNL_DEV1, "gre", "seq"); 851 set_fd = bpf_program__fd(skel->progs.gre_set_tunnel_no_key); 852 get_fd = bpf_program__fd(skel->progs.gre_get_tunnel); 853 break; 854 case GRE_NOKEY: 855 err = add_ipv4_tunnel(GRE_TUNL_DEV0, GRE_TUNL_DEV1, "gre", "seq key 2"); 856 set_fd = bpf_program__fd(skel->progs.gre_set_tunnel); 857 get_fd = bpf_program__fd(skel->progs.gre_get_tunnel); 858 break; 859 case GRETAP: 860 err = add_ipv4_tunnel(GRE_TUNL_DEV0, GRE_TUNL_DEV1, "gretap", "seq"); 861 set_fd = bpf_program__fd(skel->progs.gre_set_tunnel_no_key); 862 get_fd = bpf_program__fd(skel->progs.gre_get_tunnel); 863 break; 864 case GRETAP_NOKEY: 865 err = add_ipv4_tunnel(GRE_TUNL_DEV0, GRE_TUNL_DEV1, "gretap", "seq key 2"); 866 set_fd = bpf_program__fd(skel->progs.gre_set_tunnel); 867 get_fd = bpf_program__fd(skel->progs.gre_get_tunnel); 868 break; 869 } 870 if (!ASSERT_OK(err, "add tunnel")) 871 goto done; 872 873 if (generic_attach(GRE_TUNL_DEV1, get_fd, set_fd)) 874 goto done; 875 876 ping_dev0(); 877 ping_dev1(); 878 879 done: 880 delete_tunnel(GRE_TUNL_DEV0, GRE_TUNL_DEV1); 881 test_tunnel_kern__destroy(skel); 882 } 883 884 enum ip6gre_test { 885 IP6GRE, 886 IP6GRETAP 887 }; 888 889 static void test_ip6gre_tunnel(enum ip6gre_test test) 890 { 891 struct test_tunnel_kern *skel; 892 int set_fd, get_fd; 893 int err; 894 895 skel = test_tunnel_kern__open_and_load(); 896 if (!ASSERT_OK_PTR(skel, "test_tunnel_kern__open_and_load")) 897 return; 898 899 switch (test) { 900 case IP6GRE: 901 err = add_ipv6_tunnel(IP6GRE_TUNL_DEV0, IP6GRE_TUNL_DEV1, 902 "ip6gre", "flowlabel 0xbcdef key 2"); 903 break; 904 case IP6GRETAP: 905 err = add_ipv6_tunnel(IP6GRE_TUNL_DEV0, IP6GRE_TUNL_DEV1, 906 "ip6gretap", "flowlabel 0xbcdef key 2"); 907 break; 908 } 909 if (!ASSERT_OK(err, "add tunnel")) 910 goto done; 911 912 set_fd = bpf_program__fd(skel->progs.ip6gretap_set_tunnel); 913 get_fd = bpf_program__fd(skel->progs.ip6gretap_get_tunnel); 914 if (generic_attach(IP6GRE_TUNL_DEV1, get_fd, set_fd)) 915 goto done; 916 917 ping6_veth0(); 918 ping6_dev1(); 919 ping_dev0(); 920 ping_dev1(); 921 done: 922 delete_tunnel(IP6GRE_TUNL_DEV0, IP6GRE_TUNL_DEV1); 923 test_tunnel_kern__destroy(skel); 924 } 925 926 enum erspan_test { 927 V1, 928 V2 929 }; 930 931 static void test_erspan_tunnel(enum erspan_test test) 932 { 933 struct test_tunnel_kern *skel; 934 int set_fd, get_fd; 935 int err; 936 937 skel = test_tunnel_kern__open_and_load(); 938 if (!ASSERT_OK_PTR(skel, "test_tunnel_kern__open_and_load")) 939 return; 940 941 switch (test) { 942 case V1: 943 err = add_ipv4_tunnel(ERSPAN_TUNL_DEV0, ERSPAN_TUNL_DEV1, 944 "erspan", "seq key 2 erspan_ver 1 erspan 123"); 945 break; 946 case V2: 947 err = add_ipv4_tunnel(ERSPAN_TUNL_DEV0, ERSPAN_TUNL_DEV1, 948 "erspan", 949 "seq key 2 erspan_ver 2 erspan_dir egress erspan_hwid 3"); 950 break; 951 } 952 if (!ASSERT_OK(err, "add tunnel")) 953 goto done; 954 955 set_fd = bpf_program__fd(skel->progs.erspan_set_tunnel); 956 get_fd = bpf_program__fd(skel->progs.erspan_get_tunnel); 957 if (generic_attach(ERSPAN_TUNL_DEV1, get_fd, set_fd)) 958 goto done; 959 960 ping_dev0(); 961 ping_dev1(); 962 done: 963 delete_tunnel(ERSPAN_TUNL_DEV0, ERSPAN_TUNL_DEV1); 964 test_tunnel_kern__destroy(skel); 965 } 966 967 static void test_ip6erspan_tunnel(enum erspan_test test) 968 { 969 struct test_tunnel_kern *skel; 970 int set_fd, get_fd; 971 int err; 972 973 skel = test_tunnel_kern__open_and_load(); 974 if (!ASSERT_OK_PTR(skel, "test_tunnel_kern__open_and_load")) 975 return; 976 977 switch (test) { 978 case V1: 979 err = add_ipv6_tunnel(IP6ERSPAN_TUNL_DEV0, IP6ERSPAN_TUNL_DEV1, 980 "ip6erspan", "seq key 2 erspan_ver 1 erspan 123"); 981 break; 982 case V2: 983 err = add_ipv6_tunnel(IP6ERSPAN_TUNL_DEV0, IP6ERSPAN_TUNL_DEV1, 984 "ip6erspan", 985 "seq key 2 erspan_ver 2 erspan_dir egress erspan_hwid 7"); 986 break; 987 } 988 if (!ASSERT_OK(err, "add tunnel")) 989 goto done; 990 991 set_fd = bpf_program__fd(skel->progs.ip4ip6erspan_set_tunnel); 992 get_fd = bpf_program__fd(skel->progs.ip4ip6erspan_get_tunnel); 993 if (generic_attach(IP6ERSPAN_TUNL_DEV1, get_fd, set_fd)) 994 goto done; 995 996 ping6_veth0(); 997 ping_dev1(); 998 done: 999 delete_tunnel(IP6ERSPAN_TUNL_DEV0, IP6ERSPAN_TUNL_DEV1); 1000 test_tunnel_kern__destroy(skel); 1001 } 1002 1003 static void test_geneve_tunnel(void) 1004 { 1005 struct test_tunnel_kern *skel; 1006 int set_fd, get_fd; 1007 int err; 1008 1009 skel = test_tunnel_kern__open_and_load(); 1010 if (!ASSERT_OK_PTR(skel, "test_tunnel_kern__open_and_load")) 1011 return; 1012 1013 err = add_geneve_tunnel(GENEVE_TUNL_DEV0, GENEVE_TUNL_DEV1, 1014 "geneve", "dstport 6081"); 1015 if (!ASSERT_OK(err, "add tunnel")) 1016 goto done; 1017 1018 set_fd = bpf_program__fd(skel->progs.geneve_set_tunnel); 1019 get_fd = bpf_program__fd(skel->progs.geneve_get_tunnel); 1020 if (generic_attach(GENEVE_TUNL_DEV1, get_fd, set_fd)) 1021 goto done; 1022 1023 ping_dev0(); 1024 ping_dev1(); 1025 done: 1026 delete_tunnel(GENEVE_TUNL_DEV0, GENEVE_TUNL_DEV1); 1027 test_tunnel_kern__destroy(skel); 1028 } 1029 1030 static void test_ip6geneve_tunnel(void) 1031 { 1032 struct test_tunnel_kern *skel; 1033 int set_fd, get_fd; 1034 int err; 1035 1036 skel = test_tunnel_kern__open_and_load(); 1037 if (!ASSERT_OK_PTR(skel, "test_tunnel_kern__open_and_load")) 1038 return; 1039 1040 err = add_ip6geneve_tunnel(IP6GENEVE_TUNL_DEV0, IP6GENEVE_TUNL_DEV1, 1041 "geneve", ""); 1042 if (!ASSERT_OK(err, "add tunnel")) 1043 goto done; 1044 1045 set_fd = bpf_program__fd(skel->progs.ip6geneve_set_tunnel); 1046 get_fd = bpf_program__fd(skel->progs.ip6geneve_get_tunnel); 1047 if (generic_attach(IP6GENEVE_TUNL_DEV1, get_fd, set_fd)) 1048 goto done; 1049 1050 ping_dev0(); 1051 ping_dev1(); 1052 done: 1053 delete_tunnel(IP6GENEVE_TUNL_DEV0, IP6GENEVE_TUNL_DEV1); 1054 test_tunnel_kern__destroy(skel); 1055 } 1056 1057 enum ip6tnl_test { 1058 IPIP6, 1059 IP6IP6 1060 }; 1061 1062 static void test_ip6tnl_tunnel(enum ip6tnl_test test) 1063 { 1064 struct test_tunnel_kern *skel; 1065 int set_fd, get_fd; 1066 int err; 1067 1068 skel = test_tunnel_kern__open_and_load(); 1069 if (!ASSERT_OK_PTR(skel, "test_tunnel_kern__open_and_load")) 1070 return; 1071 1072 err = add_ipv6_tunnel(IP6TNL_TUNL_DEV0, IP6TNL_TUNL_DEV1, "ip6tnl", ""); 1073 if (!ASSERT_OK(err, "add tunnel")) 1074 goto done; 1075 1076 switch (test) { 1077 case IPIP6: 1078 set_fd = bpf_program__fd(skel->progs.ipip6_set_tunnel); 1079 get_fd = bpf_program__fd(skel->progs.ipip6_get_tunnel); 1080 break; 1081 case IP6IP6: 1082 set_fd = bpf_program__fd(skel->progs.ip6ip6_set_tunnel); 1083 get_fd = bpf_program__fd(skel->progs.ip6ip6_get_tunnel); 1084 break; 1085 } 1086 if (generic_attach(IP6TNL_TUNL_DEV1, get_fd, set_fd)) 1087 goto done; 1088 1089 ping6_veth0(); 1090 switch (test) { 1091 case IPIP6: 1092 ping_dev0(); 1093 ping_dev1(); 1094 break; 1095 case IP6IP6: 1096 ping6_dev0(); 1097 ping6_dev1(); 1098 break; 1099 } 1100 1101 done: 1102 delete_tunnel(IP6TNL_TUNL_DEV0, IP6TNL_TUNL_DEV1); 1103 test_tunnel_kern__destroy(skel); 1104 } 1105 1106 #define RUN_TEST(name, ...) \ 1107 ({ \ 1108 if (test__start_subtest(#name)) { \ 1109 config_device(); \ 1110 test_ ## name(__VA_ARGS__); \ 1111 cleanup(); \ 1112 } \ 1113 }) 1114 1115 static void *test_tunnel_run_tests(void *arg) 1116 { 1117 RUN_TEST(vxlan_tunnel); 1118 RUN_TEST(ip6vxlan_tunnel); 1119 RUN_TEST(ipip_tunnel, NONE); 1120 RUN_TEST(ipip_tunnel, FOU); 1121 RUN_TEST(ipip_tunnel, GUE); 1122 RUN_TEST(xfrm_tunnel); 1123 RUN_TEST(gre_tunnel, GRE); 1124 RUN_TEST(gre_tunnel, GRE_NOKEY); 1125 RUN_TEST(gre_tunnel, GRETAP); 1126 RUN_TEST(gre_tunnel, GRETAP_NOKEY); 1127 RUN_TEST(ip6gre_tunnel, IP6GRE); 1128 RUN_TEST(ip6gre_tunnel, IP6GRETAP); 1129 RUN_TEST(erspan_tunnel, V1); 1130 RUN_TEST(erspan_tunnel, V2); 1131 RUN_TEST(ip6erspan_tunnel, V1); 1132 RUN_TEST(ip6erspan_tunnel, V2); 1133 RUN_TEST(geneve_tunnel); 1134 RUN_TEST(ip6geneve_tunnel); 1135 RUN_TEST(ip6tnl_tunnel, IPIP6); 1136 RUN_TEST(ip6tnl_tunnel, IP6IP6); 1137 1138 return NULL; 1139 } 1140 1141 void test_tunnel(void) 1142 { 1143 pthread_t test_thread; 1144 int err; 1145 1146 /* Run the tests in their own thread to isolate the namespace changes 1147 * so they do not affect the environment of other tests. 1148 * (specifically needed because of unshare(CLONE_NEWNS) in open_netns()) 1149 */ 1150 err = pthread_create(&test_thread, NULL, &test_tunnel_run_tests, NULL); 1151 if (ASSERT_OK(err, "pthread_create")) 1152 ASSERT_OK(pthread_join(test_thread, NULL), "pthread_join"); 1153 } 1154