1 // SPDX-License-Identifier: GPL-2.0 2 #ifndef _XDP_SAMPLE_BPF_H 3 #define _XDP_SAMPLE_BPF_H 4 5 #include "vmlinux.h" 6 #include <bpf/bpf_tracing.h> 7 #include <bpf/bpf_core_read.h> 8 #include <bpf/bpf_helpers.h> 9 10 #include "xdp_sample_shared.h" 11 12 #define ETH_ALEN 6 13 #define ETH_P_802_3_MIN 0x0600 14 #define ETH_P_8021Q 0x8100 15 #define ETH_P_8021AD 0x88A8 16 #define ETH_P_IP 0x0800 17 #define ETH_P_IPV6 0x86DD 18 #define ETH_P_ARP 0x0806 19 #define IPPROTO_ICMPV6 58 20 21 #define EINVAL 22 22 #define ENETDOWN 100 23 #define EMSGSIZE 90 24 #define EOPNOTSUPP 95 25 #define ENOSPC 28 26 27 typedef struct { 28 __uint(type, BPF_MAP_TYPE_ARRAY); 29 __uint(map_flags, BPF_F_MMAPABLE); 30 __type(key, unsigned int); 31 __type(value, struct datarec); 32 } array_map; 33 34 extern array_map rx_cnt; 35 extern const volatile int nr_cpus; 36 37 enum { 38 XDP_REDIRECT_SUCCESS = 0, 39 XDP_REDIRECT_ERROR = 1 40 }; 41 42 static __always_inline void swap_src_dst_mac(void *data) 43 { 44 unsigned short *p = data; 45 unsigned short dst[3]; 46 47 dst[0] = p[0]; 48 dst[1] = p[1]; 49 dst[2] = p[2]; 50 p[0] = p[3]; 51 p[1] = p[4]; 52 p[2] = p[5]; 53 p[3] = dst[0]; 54 p[4] = dst[1]; 55 p[5] = dst[2]; 56 } 57 58 #if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \ 59 __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 60 #define bpf_ntohs(x) __builtin_bswap16(x) 61 #define bpf_htons(x) __builtin_bswap16(x) 62 #elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \ 63 __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ 64 #define bpf_ntohs(x) (x) 65 #define bpf_htons(x) (x) 66 #else 67 # error "Endianness detection needs to be set up for your compiler?!" 68 #endif 69 70 /* 71 * Note: including linux/compiler.h or linux/kernel.h for the macros below 72 * conflicts with vmlinux.h include in BPF files, so we define them here. 73 * 74 * Following functions are taken from kernel sources and 75 * break aliasing rules in their original form. 76 * 77 * While kernel is compiled with -fno-strict-aliasing, 78 * perf uses -Wstrict-aliasing=3 which makes build fail 79 * under gcc 4.4. 80 * 81 * Using extra __may_alias__ type to allow aliasing 82 * in this case. 83 */ 84 typedef __u8 __attribute__((__may_alias__)) __u8_alias_t; 85 typedef __u16 __attribute__((__may_alias__)) __u16_alias_t; 86 typedef __u32 __attribute__((__may_alias__)) __u32_alias_t; 87 typedef __u64 __attribute__((__may_alias__)) __u64_alias_t; 88 89 static __always_inline void __read_once_size(const volatile void *p, void *res, int size) 90 { 91 switch (size) { 92 case 1: *(__u8_alias_t *) res = *(volatile __u8_alias_t *) p; break; 93 case 2: *(__u16_alias_t *) res = *(volatile __u16_alias_t *) p; break; 94 case 4: *(__u32_alias_t *) res = *(volatile __u32_alias_t *) p; break; 95 case 8: *(__u64_alias_t *) res = *(volatile __u64_alias_t *) p; break; 96 default: 97 asm volatile ("" : : : "memory"); 98 __builtin_memcpy((void *)res, (const void *)p, size); 99 asm volatile ("" : : : "memory"); 100 } 101 } 102 103 static __always_inline void __write_once_size(volatile void *p, void *res, int size) 104 { 105 switch (size) { 106 case 1: *(volatile __u8_alias_t *) p = *(__u8_alias_t *) res; break; 107 case 2: *(volatile __u16_alias_t *) p = *(__u16_alias_t *) res; break; 108 case 4: *(volatile __u32_alias_t *) p = *(__u32_alias_t *) res; break; 109 case 8: *(volatile __u64_alias_t *) p = *(__u64_alias_t *) res; break; 110 default: 111 asm volatile ("" : : : "memory"); 112 __builtin_memcpy((void *)p, (const void *)res, size); 113 asm volatile ("" : : : "memory"); 114 } 115 } 116 117 #define READ_ONCE(x) \ 118 ({ \ 119 union { typeof(x) __val; char __c[1]; } __u = \ 120 { .__c = { 0 } }; \ 121 __read_once_size(&(x), __u.__c, sizeof(x)); \ 122 __u.__val; \ 123 }) 124 125 #define WRITE_ONCE(x, val) \ 126 ({ \ 127 union { typeof(x) __val; char __c[1]; } __u = \ 128 { .__val = (val) }; \ 129 __write_once_size(&(x), __u.__c, sizeof(x)); \ 130 __u.__val; \ 131 }) 132 133 /* Add a value using relaxed read and relaxed write. Less expensive than 134 * fetch_add when there is no write concurrency. 135 */ 136 #define NO_TEAR_ADD(x, val) WRITE_ONCE((x), READ_ONCE(x) + (val)) 137 #define NO_TEAR_INC(x) NO_TEAR_ADD((x), 1) 138 139 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) 140 141 #endif 142