Commit | Line | Data |
---|---|---|
32314038 KKD |
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 | ||
e69fe845 | 10 | #include "net_shared.h" |
32314038 KKD |
11 | #include "xdp_sample_shared.h" |
12 | ||
32314038 KKD |
13 | #define EINVAL 22 |
14 | #define ENETDOWN 100 | |
15 | #define EMSGSIZE 90 | |
16 | #define EOPNOTSUPP 95 | |
17 | #define ENOSPC 28 | |
18 | ||
19 | typedef struct { | |
20 | __uint(type, BPF_MAP_TYPE_ARRAY); | |
21 | __uint(map_flags, BPF_F_MMAPABLE); | |
22 | __type(key, unsigned int); | |
23 | __type(value, struct datarec); | |
24 | } array_map; | |
25 | ||
26 | extern array_map rx_cnt; | |
27 | extern const volatile int nr_cpus; | |
28 | ||
29 | enum { | |
30 | XDP_REDIRECT_SUCCESS = 0, | |
31 | XDP_REDIRECT_ERROR = 1 | |
32 | }; | |
33 | ||
34 | static __always_inline void swap_src_dst_mac(void *data) | |
35 | { | |
36 | unsigned short *p = data; | |
37 | unsigned short dst[3]; | |
38 | ||
39 | dst[0] = p[0]; | |
40 | dst[1] = p[1]; | |
41 | dst[2] = p[2]; | |
42 | p[0] = p[3]; | |
43 | p[1] = p[4]; | |
44 | p[2] = p[5]; | |
45 | p[3] = dst[0]; | |
46 | p[4] = dst[1]; | |
47 | p[5] = dst[2]; | |
48 | } | |
49 | ||
32314038 KKD |
50 | /* |
51 | * Note: including linux/compiler.h or linux/kernel.h for the macros below | |
52 | * conflicts with vmlinux.h include in BPF files, so we define them here. | |
53 | * | |
54 | * Following functions are taken from kernel sources and | |
55 | * break aliasing rules in their original form. | |
56 | * | |
57 | * While kernel is compiled with -fno-strict-aliasing, | |
58 | * perf uses -Wstrict-aliasing=3 which makes build fail | |
59 | * under gcc 4.4. | |
60 | * | |
61 | * Using extra __may_alias__ type to allow aliasing | |
62 | * in this case. | |
63 | */ | |
64 | typedef __u8 __attribute__((__may_alias__)) __u8_alias_t; | |
65 | typedef __u16 __attribute__((__may_alias__)) __u16_alias_t; | |
66 | typedef __u32 __attribute__((__may_alias__)) __u32_alias_t; | |
67 | typedef __u64 __attribute__((__may_alias__)) __u64_alias_t; | |
68 | ||
69 | static __always_inline void __read_once_size(const volatile void *p, void *res, int size) | |
70 | { | |
71 | switch (size) { | |
72 | case 1: *(__u8_alias_t *) res = *(volatile __u8_alias_t *) p; break; | |
73 | case 2: *(__u16_alias_t *) res = *(volatile __u16_alias_t *) p; break; | |
74 | case 4: *(__u32_alias_t *) res = *(volatile __u32_alias_t *) p; break; | |
75 | case 8: *(__u64_alias_t *) res = *(volatile __u64_alias_t *) p; break; | |
76 | default: | |
77 | asm volatile ("" : : : "memory"); | |
78 | __builtin_memcpy((void *)res, (const void *)p, size); | |
79 | asm volatile ("" : : : "memory"); | |
80 | } | |
81 | } | |
82 | ||
83 | static __always_inline void __write_once_size(volatile void *p, void *res, int size) | |
84 | { | |
85 | switch (size) { | |
86 | case 1: *(volatile __u8_alias_t *) p = *(__u8_alias_t *) res; break; | |
87 | case 2: *(volatile __u16_alias_t *) p = *(__u16_alias_t *) res; break; | |
88 | case 4: *(volatile __u32_alias_t *) p = *(__u32_alias_t *) res; break; | |
89 | case 8: *(volatile __u64_alias_t *) p = *(__u64_alias_t *) res; break; | |
90 | default: | |
91 | asm volatile ("" : : : "memory"); | |
92 | __builtin_memcpy((void *)p, (const void *)res, size); | |
93 | asm volatile ("" : : : "memory"); | |
94 | } | |
95 | } | |
96 | ||
97 | #define READ_ONCE(x) \ | |
98 | ({ \ | |
99 | union { typeof(x) __val; char __c[1]; } __u = \ | |
100 | { .__c = { 0 } }; \ | |
101 | __read_once_size(&(x), __u.__c, sizeof(x)); \ | |
102 | __u.__val; \ | |
103 | }) | |
104 | ||
105 | #define WRITE_ONCE(x, val) \ | |
106 | ({ \ | |
107 | union { typeof(x) __val; char __c[1]; } __u = \ | |
108 | { .__val = (val) }; \ | |
109 | __write_once_size(&(x), __u.__c, sizeof(x)); \ | |
110 | __u.__val; \ | |
111 | }) | |
112 | ||
113 | /* Add a value using relaxed read and relaxed write. Less expensive than | |
114 | * fetch_add when there is no write concurrency. | |
115 | */ | |
116 | #define NO_TEAR_ADD(x, val) WRITE_ONCE((x), READ_ONCE(x) + (val)) | |
117 | #define NO_TEAR_INC(x) NO_TEAR_ADD((x), 1) | |
118 | ||
119 | #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) | |
120 | ||
121 | #endif |