1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (c) 2017 Facebook 3 #include <stddef.h> 4 #include <stdbool.h> 5 #include <string.h> 6 #include <linux/pkt_cls.h> 7 #include <linux/bpf.h> 8 #include <linux/in.h> 9 #include <linux/if_ether.h> 10 #include <linux/ip.h> 11 #include <linux/ipv6.h> 12 #include <linux/icmp.h> 13 #include <linux/icmpv6.h> 14 #include <linux/tcp.h> 15 #include <linux/udp.h> 16 #include <bpf/bpf_helpers.h> 17 #include <bpf/bpf_endian.h> 18 19 static __always_inline __u32 rol32(__u32 word, unsigned int shift) 20 { 21 return (word << shift) | (word >> ((-shift) & 31)); 22 } 23 24 /* copy paste of jhash from kernel sources to make sure llvm 25 * can compile it into valid sequence of bpf instructions 26 */ 27 #define __jhash_mix(a, b, c) \ 28 { \ 29 a -= c; a ^= rol32(c, 4); c += b; \ 30 b -= a; b ^= rol32(a, 6); a += c; \ 31 c -= b; c ^= rol32(b, 8); b += a; \ 32 a -= c; a ^= rol32(c, 16); c += b; \ 33 b -= a; b ^= rol32(a, 19); a += c; \ 34 c -= b; c ^= rol32(b, 4); b += a; \ 35 } 36 37 #define __jhash_final(a, b, c) \ 38 { \ 39 c ^= b; c -= rol32(b, 14); \ 40 a ^= c; a -= rol32(c, 11); \ 41 b ^= a; b -= rol32(a, 25); \ 42 c ^= b; c -= rol32(b, 16); \ 43 a ^= c; a -= rol32(c, 4); \ 44 b ^= a; b -= rol32(a, 14); \ 45 c ^= b; c -= rol32(b, 24); \ 46 } 47 48 #define JHASH_INITVAL 0xdeadbeef 49 50 typedef unsigned int u32; 51 52 static __noinline 53 u32 jhash(const void *key, u32 length, u32 initval) 54 { 55 u32 a, b, c; 56 const unsigned char *k = key; 57 58 a = b = c = JHASH_INITVAL + length + initval; 59 60 while (length > 12) { 61 a += *(u32 *)(k); 62 b += *(u32 *)(k + 4); 63 c += *(u32 *)(k + 8); 64 __jhash_mix(a, b, c); 65 length -= 12; 66 k += 12; 67 } 68 switch (length) { 69 case 12: c += (u32)k[11]<<24; 70 case 11: c += (u32)k[10]<<16; 71 case 10: c += (u32)k[9]<<8; 72 case 9: c += k[8]; 73 case 8: b += (u32)k[7]<<24; 74 case 7: b += (u32)k[6]<<16; 75 case 6: b += (u32)k[5]<<8; 76 case 5: b += k[4]; 77 case 4: a += (u32)k[3]<<24; 78 case 3: a += (u32)k[2]<<16; 79 case 2: a += (u32)k[1]<<8; 80 case 1: a += k[0]; 81 __jhash_final(a, b, c); 82 case 0: /* Nothing left to add */ 83 break; 84 } 85 86 return c; 87 } 88 89 __noinline 90 u32 __jhash_nwords(u32 a, u32 b, u32 c, u32 initval) 91 { 92 a += initval; 93 b += initval; 94 c += initval; 95 __jhash_final(a, b, c); 96 return c; 97 } 98 99 __noinline 100 u32 jhash_2words(u32 a, u32 b, u32 initval) 101 { 102 return __jhash_nwords(a, b, 0, initval + JHASH_INITVAL + (2 << 2)); 103 } 104 105 struct flow_key { 106 union { 107 __be32 src; 108 __be32 srcv6[4]; 109 }; 110 union { 111 __be32 dst; 112 __be32 dstv6[4]; 113 }; 114 union { 115 __u32 ports; 116 __u16 port16[2]; 117 }; 118 __u8 proto; 119 }; 120 121 struct packet_description { 122 struct flow_key flow; 123 __u8 flags; 124 }; 125 126 struct ctl_value { 127 union { 128 __u64 value; 129 __u32 ifindex; 130 __u8 mac[6]; 131 }; 132 }; 133 134 struct vip_definition { 135 union { 136 __be32 vip; 137 __be32 vipv6[4]; 138 }; 139 __u16 port; 140 __u16 family; 141 __u8 proto; 142 }; 143 144 struct vip_meta { 145 __u32 flags; 146 __u32 vip_num; 147 }; 148 149 struct real_pos_lru { 150 __u32 pos; 151 __u64 atime; 152 }; 153 154 struct real_definition { 155 union { 156 __be32 dst; 157 __be32 dstv6[4]; 158 }; 159 __u8 flags; 160 }; 161 162 struct lb_stats { 163 __u64 v2; 164 __u64 v1; 165 }; 166 167 struct { 168 __uint(type, BPF_MAP_TYPE_HASH); 169 __uint(max_entries, 512); 170 __type(key, struct vip_definition); 171 __type(value, struct vip_meta); 172 } vip_map SEC(".maps"); 173 174 struct { 175 __uint(type, BPF_MAP_TYPE_LRU_HASH); 176 __uint(max_entries, 300); 177 __uint(map_flags, 1U << 1); 178 __type(key, struct flow_key); 179 __type(value, struct real_pos_lru); 180 } lru_cache SEC(".maps"); 181 182 struct { 183 __uint(type, BPF_MAP_TYPE_ARRAY); 184 __uint(max_entries, 12 * 655); 185 __type(key, __u32); 186 __type(value, __u32); 187 } ch_rings SEC(".maps"); 188 189 struct { 190 __uint(type, BPF_MAP_TYPE_ARRAY); 191 __uint(max_entries, 40); 192 __type(key, __u32); 193 __type(value, struct real_definition); 194 } reals SEC(".maps"); 195 196 struct { 197 __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY); 198 __uint(max_entries, 515); 199 __type(key, __u32); 200 __type(value, struct lb_stats); 201 } stats SEC(".maps"); 202 203 struct { 204 __uint(type, BPF_MAP_TYPE_ARRAY); 205 __uint(max_entries, 16); 206 __type(key, __u32); 207 __type(value, struct ctl_value); 208 } ctl_array SEC(".maps"); 209 210 struct eth_hdr { 211 unsigned char eth_dest[6]; 212 unsigned char eth_source[6]; 213 unsigned short eth_proto; 214 }; 215 216 static __noinline __u64 calc_offset(bool is_ipv6, bool is_icmp) 217 { 218 __u64 off = sizeof(struct eth_hdr); 219 if (is_ipv6) { 220 off += sizeof(struct ipv6hdr); 221 if (is_icmp) 222 off += sizeof(struct icmp6hdr) + sizeof(struct ipv6hdr); 223 } else { 224 off += sizeof(struct iphdr); 225 if (is_icmp) 226 off += sizeof(struct icmphdr) + sizeof(struct iphdr); 227 } 228 return off; 229 } 230 231 static __attribute__ ((noinline)) 232 bool parse_udp(void *data, void *data_end, 233 bool is_ipv6, struct packet_description *pckt) 234 { 235 236 bool is_icmp = !((pckt->flags & (1 << 0)) == 0); 237 __u64 off = calc_offset(is_ipv6, is_icmp); 238 struct udphdr *udp; 239 udp = data + off; 240 241 if (udp + 1 > data_end) 242 return 0; 243 if (!is_icmp) { 244 pckt->flow.port16[0] = udp->source; 245 pckt->flow.port16[1] = udp->dest; 246 } else { 247 pckt->flow.port16[0] = udp->dest; 248 pckt->flow.port16[1] = udp->source; 249 } 250 return 1; 251 } 252 253 static __attribute__ ((noinline)) 254 bool parse_tcp(void *data, void *data_end, 255 bool is_ipv6, struct packet_description *pckt) 256 { 257 258 bool is_icmp = !((pckt->flags & (1 << 0)) == 0); 259 __u64 off = calc_offset(is_ipv6, is_icmp); 260 struct tcphdr *tcp; 261 262 tcp = data + off; 263 if (tcp + 1 > data_end) 264 return 0; 265 if (tcp->syn) 266 pckt->flags |= (1 << 1); 267 if (!is_icmp) { 268 pckt->flow.port16[0] = tcp->source; 269 pckt->flow.port16[1] = tcp->dest; 270 } else { 271 pckt->flow.port16[0] = tcp->dest; 272 pckt->flow.port16[1] = tcp->source; 273 } 274 return 1; 275 } 276 277 static __attribute__ ((noinline)) 278 bool encap_v6(struct xdp_md *xdp, struct ctl_value *cval, 279 struct packet_description *pckt, 280 struct real_definition *dst, __u32 pkt_bytes) 281 { 282 struct eth_hdr *new_eth; 283 struct eth_hdr *old_eth; 284 struct ipv6hdr *ip6h; 285 __u32 ip_suffix; 286 void *data_end; 287 void *data; 288 289 if (bpf_xdp_adjust_head(xdp, 0 - (int)sizeof(struct ipv6hdr))) 290 return 0; 291 data = (void *)(long)xdp->data; 292 data_end = (void *)(long)xdp->data_end; 293 new_eth = data; 294 ip6h = data + sizeof(struct eth_hdr); 295 old_eth = data + sizeof(struct ipv6hdr); 296 if (new_eth + 1 > data_end || 297 old_eth + 1 > data_end || ip6h + 1 > data_end) 298 return 0; 299 memcpy(new_eth->eth_dest, cval->mac, 6); 300 memcpy(new_eth->eth_source, old_eth->eth_dest, 6); 301 new_eth->eth_proto = 56710; 302 ip6h->version = 6; 303 ip6h->priority = 0; 304 memset(ip6h->flow_lbl, 0, sizeof(ip6h->flow_lbl)); 305 306 ip6h->nexthdr = IPPROTO_IPV6; 307 ip_suffix = pckt->flow.srcv6[3] ^ pckt->flow.port16[0]; 308 ip6h->payload_len = 309 bpf_htons(pkt_bytes + sizeof(struct ipv6hdr)); 310 ip6h->hop_limit = 4; 311 312 ip6h->saddr.in6_u.u6_addr32[0] = 1; 313 ip6h->saddr.in6_u.u6_addr32[1] = 2; 314 ip6h->saddr.in6_u.u6_addr32[2] = 3; 315 ip6h->saddr.in6_u.u6_addr32[3] = ip_suffix; 316 memcpy(ip6h->daddr.in6_u.u6_addr32, dst->dstv6, 16); 317 return 1; 318 } 319 320 static __attribute__ ((noinline)) 321 bool encap_v4(struct xdp_md *xdp, struct ctl_value *cval, 322 struct packet_description *pckt, 323 struct real_definition *dst, __u32 pkt_bytes) 324 { 325 326 __u32 ip_suffix = bpf_ntohs(pckt->flow.port16[0]); 327 struct eth_hdr *new_eth; 328 struct eth_hdr *old_eth; 329 __u16 *next_iph_u16; 330 struct iphdr *iph; 331 __u32 csum = 0; 332 void *data_end; 333 void *data; 334 335 ip_suffix <<= 15; 336 ip_suffix ^= pckt->flow.src; 337 if (bpf_xdp_adjust_head(xdp, 0 - (int)sizeof(struct iphdr))) 338 return 0; 339 data = (void *)(long)xdp->data; 340 data_end = (void *)(long)xdp->data_end; 341 new_eth = data; 342 iph = data + sizeof(struct eth_hdr); 343 old_eth = data + sizeof(struct iphdr); 344 if (new_eth + 1 > data_end || 345 old_eth + 1 > data_end || iph + 1 > data_end) 346 return 0; 347 memcpy(new_eth->eth_dest, cval->mac, 6); 348 memcpy(new_eth->eth_source, old_eth->eth_dest, 6); 349 new_eth->eth_proto = 8; 350 iph->version = 4; 351 iph->ihl = 5; 352 iph->frag_off = 0; 353 iph->protocol = IPPROTO_IPIP; 354 iph->check = 0; 355 iph->tos = 1; 356 iph->tot_len = bpf_htons(pkt_bytes + sizeof(struct iphdr)); 357 /* don't update iph->daddr, since it will overwrite old eth_proto 358 * and multiple iterations of bpf_prog_run() will fail 359 */ 360 361 iph->saddr = ((0xFFFF0000 & ip_suffix) | 4268) ^ dst->dst; 362 iph->ttl = 4; 363 364 next_iph_u16 = (__u16 *) iph; 365 #pragma clang loop unroll(full) 366 for (int i = 0; i < sizeof(struct iphdr) >> 1; i++) 367 csum += *next_iph_u16++; 368 iph->check = ~((csum & 0xffff) + (csum >> 16)); 369 if (bpf_xdp_adjust_head(xdp, (int)sizeof(struct iphdr))) 370 return 0; 371 return 1; 372 } 373 374 static __attribute__ ((noinline)) 375 bool decap_v6(struct xdp_md *xdp, void **data, void **data_end, bool inner_v4) 376 { 377 struct eth_hdr *new_eth; 378 struct eth_hdr *old_eth; 379 380 old_eth = *data; 381 new_eth = *data + sizeof(struct ipv6hdr); 382 memcpy(new_eth->eth_source, old_eth->eth_source, 6); 383 memcpy(new_eth->eth_dest, old_eth->eth_dest, 6); 384 if (inner_v4) 385 new_eth->eth_proto = 8; 386 else 387 new_eth->eth_proto = 56710; 388 if (bpf_xdp_adjust_head(xdp, (int)sizeof(struct ipv6hdr))) 389 return 0; 390 *data = (void *)(long)xdp->data; 391 *data_end = (void *)(long)xdp->data_end; 392 return 1; 393 } 394 395 static __attribute__ ((noinline)) 396 bool decap_v4(struct xdp_md *xdp, void **data, void **data_end) 397 { 398 struct eth_hdr *new_eth; 399 struct eth_hdr *old_eth; 400 401 old_eth = *data; 402 new_eth = *data + sizeof(struct iphdr); 403 memcpy(new_eth->eth_source, old_eth->eth_source, 6); 404 memcpy(new_eth->eth_dest, old_eth->eth_dest, 6); 405 new_eth->eth_proto = 8; 406 if (bpf_xdp_adjust_head(xdp, (int)sizeof(struct iphdr))) 407 return 0; 408 *data = (void *)(long)xdp->data; 409 *data_end = (void *)(long)xdp->data_end; 410 return 1; 411 } 412 413 static __attribute__ ((noinline)) 414 int swap_mac_and_send(void *data, void *data_end) 415 { 416 unsigned char tmp_mac[6]; 417 struct eth_hdr *eth; 418 419 eth = data; 420 memcpy(tmp_mac, eth->eth_source, 6); 421 memcpy(eth->eth_source, eth->eth_dest, 6); 422 memcpy(eth->eth_dest, tmp_mac, 6); 423 return XDP_TX; 424 } 425 426 static __attribute__ ((noinline)) 427 int send_icmp_reply(void *data, void *data_end) 428 { 429 struct icmphdr *icmp_hdr; 430 __u16 *next_iph_u16; 431 __u32 tmp_addr = 0; 432 struct iphdr *iph; 433 __u32 csum1 = 0; 434 __u32 csum = 0; 435 __u64 off = 0; 436 437 if (data + sizeof(struct eth_hdr) 438 + sizeof(struct iphdr) + sizeof(struct icmphdr) > data_end) 439 return XDP_DROP; 440 off += sizeof(struct eth_hdr); 441 iph = data + off; 442 off += sizeof(struct iphdr); 443 icmp_hdr = data + off; 444 icmp_hdr->type = 0; 445 icmp_hdr->checksum += 0x0007; 446 iph->ttl = 4; 447 tmp_addr = iph->daddr; 448 iph->daddr = iph->saddr; 449 iph->saddr = tmp_addr; 450 iph->check = 0; 451 next_iph_u16 = (__u16 *) iph; 452 #pragma clang loop unroll(full) 453 for (int i = 0; i < sizeof(struct iphdr) >> 1; i++) 454 csum += *next_iph_u16++; 455 iph->check = ~((csum & 0xffff) + (csum >> 16)); 456 return swap_mac_and_send(data, data_end); 457 } 458 459 static __attribute__ ((noinline)) 460 int send_icmp6_reply(void *data, void *data_end) 461 { 462 struct icmp6hdr *icmp_hdr; 463 struct ipv6hdr *ip6h; 464 __be32 tmp_addr[4]; 465 __u64 off = 0; 466 467 if (data + sizeof(struct eth_hdr) 468 + sizeof(struct ipv6hdr) + sizeof(struct icmp6hdr) > data_end) 469 return XDP_DROP; 470 off += sizeof(struct eth_hdr); 471 ip6h = data + off; 472 off += sizeof(struct ipv6hdr); 473 icmp_hdr = data + off; 474 icmp_hdr->icmp6_type = 129; 475 icmp_hdr->icmp6_cksum -= 0x0001; 476 ip6h->hop_limit = 4; 477 memcpy(tmp_addr, ip6h->saddr.in6_u.u6_addr32, 16); 478 memcpy(ip6h->saddr.in6_u.u6_addr32, ip6h->daddr.in6_u.u6_addr32, 16); 479 memcpy(ip6h->daddr.in6_u.u6_addr32, tmp_addr, 16); 480 return swap_mac_and_send(data, data_end); 481 } 482 483 static __attribute__ ((noinline)) 484 int parse_icmpv6(void *data, void *data_end, __u64 off, 485 struct packet_description *pckt) 486 { 487 struct icmp6hdr *icmp_hdr; 488 struct ipv6hdr *ip6h; 489 490 icmp_hdr = data + off; 491 if (icmp_hdr + 1 > data_end) 492 return XDP_DROP; 493 if (icmp_hdr->icmp6_type == 128) 494 return send_icmp6_reply(data, data_end); 495 if (icmp_hdr->icmp6_type != 3) 496 return XDP_PASS; 497 off += sizeof(struct icmp6hdr); 498 ip6h = data + off; 499 if (ip6h + 1 > data_end) 500 return XDP_DROP; 501 pckt->flow.proto = ip6h->nexthdr; 502 pckt->flags |= (1 << 0); 503 memcpy(pckt->flow.srcv6, ip6h->daddr.in6_u.u6_addr32, 16); 504 memcpy(pckt->flow.dstv6, ip6h->saddr.in6_u.u6_addr32, 16); 505 return -1; 506 } 507 508 static __attribute__ ((noinline)) 509 int parse_icmp(void *data, void *data_end, __u64 off, 510 struct packet_description *pckt) 511 { 512 struct icmphdr *icmp_hdr; 513 struct iphdr *iph; 514 515 icmp_hdr = data + off; 516 if (icmp_hdr + 1 > data_end) 517 return XDP_DROP; 518 if (icmp_hdr->type == 8) 519 return send_icmp_reply(data, data_end); 520 if ((icmp_hdr->type != 3) || (icmp_hdr->code != 4)) 521 return XDP_PASS; 522 off += sizeof(struct icmphdr); 523 iph = data + off; 524 if (iph + 1 > data_end) 525 return XDP_DROP; 526 if (iph->ihl != 5) 527 return XDP_DROP; 528 pckt->flow.proto = iph->protocol; 529 pckt->flags |= (1 << 0); 530 pckt->flow.src = iph->daddr; 531 pckt->flow.dst = iph->saddr; 532 return -1; 533 } 534 535 static __attribute__ ((noinline)) 536 __u32 get_packet_hash(struct packet_description *pckt, 537 bool hash_16bytes) 538 { 539 if (hash_16bytes) 540 return jhash_2words(jhash(pckt->flow.srcv6, 16, 12), 541 pckt->flow.ports, 24); 542 else 543 return jhash_2words(pckt->flow.src, pckt->flow.ports, 544 24); 545 } 546 547 __attribute__ ((noinline)) 548 static bool get_packet_dst(struct real_definition **real, 549 struct packet_description *pckt, 550 struct vip_meta *vip_info, 551 bool is_ipv6, void *lru_map) 552 { 553 struct real_pos_lru new_dst_lru = { }; 554 bool hash_16bytes = is_ipv6; 555 __u32 *real_pos, hash, key; 556 __u64 cur_time; 557 558 if (vip_info->flags & (1 << 2)) 559 hash_16bytes = 1; 560 if (vip_info->flags & (1 << 3)) { 561 pckt->flow.port16[0] = pckt->flow.port16[1]; 562 memset(pckt->flow.srcv6, 0, 16); 563 } 564 hash = get_packet_hash(pckt, hash_16bytes); 565 if (hash != 0x358459b7 /* jhash of ipv4 packet */ && 566 hash != 0x2f4bc6bb /* jhash of ipv6 packet */) 567 return 0; 568 key = 2 * vip_info->vip_num + hash % 2; 569 real_pos = bpf_map_lookup_elem(&ch_rings, &key); 570 if (!real_pos) 571 return 0; 572 key = *real_pos; 573 *real = bpf_map_lookup_elem(&reals, &key); 574 if (!(*real)) 575 return 0; 576 if (!(vip_info->flags & (1 << 1))) { 577 __u32 conn_rate_key = 512 + 2; 578 struct lb_stats *conn_rate_stats = 579 bpf_map_lookup_elem(&stats, &conn_rate_key); 580 581 if (!conn_rate_stats) 582 return 1; 583 cur_time = bpf_ktime_get_ns(); 584 if ((cur_time - conn_rate_stats->v2) >> 32 > 0xffFFFF) { 585 conn_rate_stats->v1 = 1; 586 conn_rate_stats->v2 = cur_time; 587 } else { 588 conn_rate_stats->v1 += 1; 589 if (conn_rate_stats->v1 >= 1) 590 return 1; 591 } 592 if (pckt->flow.proto == IPPROTO_UDP) 593 new_dst_lru.atime = cur_time; 594 new_dst_lru.pos = key; 595 bpf_map_update_elem(lru_map, &pckt->flow, &new_dst_lru, 0); 596 } 597 return 1; 598 } 599 600 __attribute__ ((noinline)) 601 static void connection_table_lookup(struct real_definition **real, 602 struct packet_description *pckt, 603 void *lru_map) 604 { 605 606 struct real_pos_lru *dst_lru; 607 __u64 cur_time; 608 __u32 key; 609 610 dst_lru = bpf_map_lookup_elem(lru_map, &pckt->flow); 611 if (!dst_lru) 612 return; 613 if (pckt->flow.proto == IPPROTO_UDP) { 614 cur_time = bpf_ktime_get_ns(); 615 if (cur_time - dst_lru->atime > 300000) 616 return; 617 dst_lru->atime = cur_time; 618 } 619 key = dst_lru->pos; 620 *real = bpf_map_lookup_elem(&reals, &key); 621 } 622 623 /* don't believe your eyes! 624 * below function has 6 arguments whereas bpf and llvm allow maximum of 5 625 * but since it's _static_ llvm can optimize one argument away 626 */ 627 __attribute__ ((noinline)) 628 static int process_l3_headers_v6(struct packet_description *pckt, 629 __u8 *protocol, __u64 off, 630 __u16 *pkt_bytes, void *data, 631 void *data_end) 632 { 633 struct ipv6hdr *ip6h; 634 __u64 iph_len; 635 int action; 636 637 ip6h = data + off; 638 if (ip6h + 1 > data_end) 639 return XDP_DROP; 640 iph_len = sizeof(struct ipv6hdr); 641 *protocol = ip6h->nexthdr; 642 pckt->flow.proto = *protocol; 643 *pkt_bytes = bpf_ntohs(ip6h->payload_len); 644 off += iph_len; 645 if (*protocol == 45) { 646 return XDP_DROP; 647 } else if (*protocol == 59) { 648 action = parse_icmpv6(data, data_end, off, pckt); 649 if (action >= 0) 650 return action; 651 } else { 652 memcpy(pckt->flow.srcv6, ip6h->saddr.in6_u.u6_addr32, 16); 653 memcpy(pckt->flow.dstv6, ip6h->daddr.in6_u.u6_addr32, 16); 654 } 655 return -1; 656 } 657 658 __attribute__ ((noinline)) 659 static int process_l3_headers_v4(struct packet_description *pckt, 660 __u8 *protocol, __u64 off, 661 __u16 *pkt_bytes, void *data, 662 void *data_end) 663 { 664 struct iphdr *iph; 665 __u64 iph_len; 666 int action; 667 668 iph = data + off; 669 if (iph + 1 > data_end) 670 return XDP_DROP; 671 if (iph->ihl != 5) 672 return XDP_DROP; 673 *protocol = iph->protocol; 674 pckt->flow.proto = *protocol; 675 *pkt_bytes = bpf_ntohs(iph->tot_len); 676 off += 20; 677 if (iph->frag_off & 65343) 678 return XDP_DROP; 679 if (*protocol == IPPROTO_ICMP) { 680 action = parse_icmp(data, data_end, off, pckt); 681 if (action >= 0) 682 return action; 683 } else { 684 pckt->flow.src = iph->saddr; 685 pckt->flow.dst = iph->daddr; 686 } 687 return -1; 688 } 689 690 __attribute__ ((noinline)) 691 static int process_packet(void *data, __u64 off, void *data_end, 692 bool is_ipv6, struct xdp_md *xdp) 693 { 694 695 struct real_definition *dst = NULL; 696 struct packet_description pckt = { }; 697 struct vip_definition vip = { }; 698 struct lb_stats *data_stats; 699 struct eth_hdr *eth = data; 700 void *lru_map = &lru_cache; 701 struct vip_meta *vip_info; 702 __u32 lru_stats_key = 513; 703 __u32 mac_addr_pos = 0; 704 __u32 stats_key = 512; 705 struct ctl_value *cval; 706 __u16 pkt_bytes; 707 __u64 iph_len; 708 __u8 protocol; 709 __u32 vip_num; 710 int action; 711 712 if (is_ipv6) 713 action = process_l3_headers_v6(&pckt, &protocol, off, 714 &pkt_bytes, data, data_end); 715 else 716 action = process_l3_headers_v4(&pckt, &protocol, off, 717 &pkt_bytes, data, data_end); 718 if (action >= 0) 719 return action; 720 protocol = pckt.flow.proto; 721 if (protocol == IPPROTO_TCP) { 722 if (!parse_tcp(data, data_end, is_ipv6, &pckt)) 723 return XDP_DROP; 724 } else if (protocol == IPPROTO_UDP) { 725 if (!parse_udp(data, data_end, is_ipv6, &pckt)) 726 return XDP_DROP; 727 } else { 728 return XDP_TX; 729 } 730 731 if (is_ipv6) 732 memcpy(vip.vipv6, pckt.flow.dstv6, 16); 733 else 734 vip.vip = pckt.flow.dst; 735 vip.port = pckt.flow.port16[1]; 736 vip.proto = pckt.flow.proto; 737 vip_info = bpf_map_lookup_elem(&vip_map, &vip); 738 if (!vip_info) { 739 vip.port = 0; 740 vip_info = bpf_map_lookup_elem(&vip_map, &vip); 741 if (!vip_info) 742 return XDP_PASS; 743 if (!(vip_info->flags & (1 << 4))) 744 pckt.flow.port16[1] = 0; 745 } 746 if (data_end - data > 1400) 747 return XDP_DROP; 748 data_stats = bpf_map_lookup_elem(&stats, &stats_key); 749 if (!data_stats) 750 return XDP_DROP; 751 data_stats->v1 += 1; 752 if (!dst) { 753 if (vip_info->flags & (1 << 0)) 754 pckt.flow.port16[0] = 0; 755 if (!(pckt.flags & (1 << 1)) && !(vip_info->flags & (1 << 1))) 756 connection_table_lookup(&dst, &pckt, lru_map); 757 if (dst) 758 goto out; 759 if (pckt.flow.proto == IPPROTO_TCP) { 760 struct lb_stats *lru_stats = 761 bpf_map_lookup_elem(&stats, &lru_stats_key); 762 763 if (!lru_stats) 764 return XDP_DROP; 765 if (pckt.flags & (1 << 1)) 766 lru_stats->v1 += 1; 767 else 768 lru_stats->v2 += 1; 769 } 770 if (!get_packet_dst(&dst, &pckt, vip_info, is_ipv6, lru_map)) 771 return XDP_DROP; 772 data_stats->v2 += 1; 773 } 774 out: 775 cval = bpf_map_lookup_elem(&ctl_array, &mac_addr_pos); 776 if (!cval) 777 return XDP_DROP; 778 if (dst->flags & (1 << 0)) { 779 if (!encap_v6(xdp, cval, &pckt, dst, pkt_bytes)) 780 return XDP_DROP; 781 } else { 782 if (!encap_v4(xdp, cval, &pckt, dst, pkt_bytes)) 783 return XDP_DROP; 784 } 785 vip_num = vip_info->vip_num; 786 data_stats = bpf_map_lookup_elem(&stats, &vip_num); 787 if (!data_stats) 788 return XDP_DROP; 789 data_stats->v1 += 1; 790 data_stats->v2 += pkt_bytes; 791 792 data = (void *)(long)xdp->data; 793 data_end = (void *)(long)xdp->data_end; 794 if (data + 4 > data_end) 795 return XDP_DROP; 796 *(u32 *)data = dst->dst; 797 return XDP_DROP; 798 } 799 800 SEC("xdp-test-v4") 801 int balancer_ingress_v4(struct xdp_md *ctx) 802 { 803 void *data = (void *)(long)ctx->data; 804 void *data_end = (void *)(long)ctx->data_end; 805 struct eth_hdr *eth = data; 806 __u32 eth_proto; 807 __u32 nh_off; 808 809 nh_off = sizeof(struct eth_hdr); 810 if (data + nh_off > data_end) 811 return XDP_DROP; 812 eth_proto = bpf_ntohs(eth->eth_proto); 813 if (eth_proto == ETH_P_IP) 814 return process_packet(data, nh_off, data_end, 0, ctx); 815 else 816 return XDP_DROP; 817 } 818 819 SEC("xdp-test-v6") 820 int balancer_ingress_v6(struct xdp_md *ctx) 821 { 822 void *data = (void *)(long)ctx->data; 823 void *data_end = (void *)(long)ctx->data_end; 824 struct eth_hdr *eth = data; 825 __u32 eth_proto; 826 __u32 nh_off; 827 828 nh_off = sizeof(struct eth_hdr); 829 if (data + nh_off > data_end) 830 return XDP_DROP; 831 eth_proto = bpf_ntohs(eth->eth_proto); 832 if (eth_proto == ETH_P_IPV6) 833 return process_packet(data, nh_off, data_end, 1, ctx); 834 else 835 return XDP_DROP; 836 } 837 838 char _license[] SEC("license") = "GPL"; 839