xdp_adjust_tail_kern.c 3.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155
  1. /* SPDX-License-Identifier: GPL-2.0
  2. * Copyright (c) 2018 Facebook
  3. *
  4. * This program is free software; you can redistribute it and/or
  5. * modify it under the terms of version 2 of the GNU General Public
  6. * License as published by the Free Software Foundation.
  7. *
  8. * This program shows how to use bpf_xdp_adjust_tail() by
  9. * generating ICMPv4 "packet to big" (unreachable/ df bit set frag needed
  10. * to be more preice in case of v4)" where receiving packets bigger then
  11. * 600 bytes.
  12. */
  13. #define KBUILD_MODNAME "foo"
  14. #include <uapi/linux/bpf.h>
  15. #include <linux/in.h>
  16. #include <linux/if_ether.h>
  17. #include <linux/if_packet.h>
  18. #include <linux/if_vlan.h>
  19. #include <linux/ip.h>
  20. #include <linux/icmp.h>
  21. #include <bpf/bpf_helpers.h>
  22. #define DEFAULT_TTL 64
  23. #define MAX_PCKT_SIZE 600
  24. #define ICMP_TOOBIG_SIZE 98
  25. #define ICMP_TOOBIG_PAYLOAD_SIZE 92
  26. /* volatile to prevent compiler optimizations */
  27. static volatile __u32 max_pcktsz = MAX_PCKT_SIZE;
  28. struct {
  29. __uint(type, BPF_MAP_TYPE_ARRAY);
  30. __type(key, __u32);
  31. __type(value, __u64);
  32. __uint(max_entries, 1);
  33. } icmpcnt SEC(".maps");
  34. static __always_inline void count_icmp(void)
  35. {
  36. u64 key = 0;
  37. u64 *icmp_count;
  38. icmp_count = bpf_map_lookup_elem(&icmpcnt, &key);
  39. if (icmp_count)
  40. *icmp_count += 1;
  41. }
  42. static __always_inline void swap_mac(void *data, struct ethhdr *orig_eth)
  43. {
  44. struct ethhdr *eth;
  45. eth = data;
  46. memcpy(eth->h_source, orig_eth->h_dest, ETH_ALEN);
  47. memcpy(eth->h_dest, orig_eth->h_source, ETH_ALEN);
  48. eth->h_proto = orig_eth->h_proto;
  49. }
  50. static __always_inline __u16 csum_fold_helper(__u32 csum)
  51. {
  52. return ~((csum & 0xffff) + (csum >> 16));
  53. }
  54. static __always_inline void ipv4_csum(void *data_start, int data_size,
  55. __u32 *csum)
  56. {
  57. *csum = bpf_csum_diff(0, 0, data_start, data_size, *csum);
  58. *csum = csum_fold_helper(*csum);
  59. }
  60. static __always_inline int send_icmp4_too_big(struct xdp_md *xdp)
  61. {
  62. int headroom = (int)sizeof(struct iphdr) + (int)sizeof(struct icmphdr);
  63. if (bpf_xdp_adjust_head(xdp, 0 - headroom))
  64. return XDP_DROP;
  65. void *data = (void *)(long)xdp->data;
  66. void *data_end = (void *)(long)xdp->data_end;
  67. if (data + (ICMP_TOOBIG_SIZE + headroom) > data_end)
  68. return XDP_DROP;
  69. struct iphdr *iph, *orig_iph;
  70. struct icmphdr *icmp_hdr;
  71. struct ethhdr *orig_eth;
  72. __u32 csum = 0;
  73. __u64 off = 0;
  74. orig_eth = data + headroom;
  75. swap_mac(data, orig_eth);
  76. off += sizeof(struct ethhdr);
  77. iph = data + off;
  78. off += sizeof(struct iphdr);
  79. icmp_hdr = data + off;
  80. off += sizeof(struct icmphdr);
  81. orig_iph = data + off;
  82. icmp_hdr->type = ICMP_DEST_UNREACH;
  83. icmp_hdr->code = ICMP_FRAG_NEEDED;
  84. icmp_hdr->un.frag.mtu = htons(max_pcktsz - sizeof(struct ethhdr));
  85. icmp_hdr->checksum = 0;
  86. ipv4_csum(icmp_hdr, ICMP_TOOBIG_PAYLOAD_SIZE, &csum);
  87. icmp_hdr->checksum = csum;
  88. iph->ttl = DEFAULT_TTL;
  89. iph->daddr = orig_iph->saddr;
  90. iph->saddr = orig_iph->daddr;
  91. iph->version = 4;
  92. iph->ihl = 5;
  93. iph->protocol = IPPROTO_ICMP;
  94. iph->tos = 0;
  95. iph->tot_len = htons(
  96. ICMP_TOOBIG_SIZE + headroom - sizeof(struct ethhdr));
  97. iph->check = 0;
  98. csum = 0;
  99. ipv4_csum(iph, sizeof(struct iphdr), &csum);
  100. iph->check = csum;
  101. count_icmp();
  102. return XDP_TX;
  103. }
  104. static __always_inline int handle_ipv4(struct xdp_md *xdp)
  105. {
  106. void *data_end = (void *)(long)xdp->data_end;
  107. void *data = (void *)(long)xdp->data;
  108. int pckt_size = data_end - data;
  109. int offset;
  110. if (pckt_size > max(max_pcktsz, ICMP_TOOBIG_SIZE)) {
  111. offset = pckt_size - ICMP_TOOBIG_SIZE;
  112. if (bpf_xdp_adjust_tail(xdp, 0 - offset))
  113. return XDP_PASS;
  114. return send_icmp4_too_big(xdp);
  115. }
  116. return XDP_PASS;
  117. }
  118. SEC("xdp_icmp")
  119. int _xdp_icmp(struct xdp_md *xdp)
  120. {
  121. void *data_end = (void *)(long)xdp->data_end;
  122. void *data = (void *)(long)xdp->data;
  123. struct ethhdr *eth = data;
  124. __u16 h_proto;
  125. if (eth + 1 > data_end)
  126. return XDP_DROP;
  127. h_proto = eth->h_proto;
  128. if (h_proto == htons(ETH_P_IP))
  129. return handle_ipv4(xdp);
  130. else
  131. return XDP_PASS;
  132. }
  133. char _license[] SEC("license") = "GPL";