GNU Linux-libre 6.6.15-gnu
[releases.git] / samples / bpf / test_lwt_bpf.c
1 /* Copyright (c) 2016 Thomas Graf <tgraf@tgraf.ch>
2  *
3  * This program is free software; you can redistribute it and/or
4  * modify it under the terms of version 2 of the GNU General Public
5  * License as published by the Free Software Foundation.
6  *
7  * This program is distributed in the hope that it will be useful, but
8  * WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
10  * General Public License for more details.
11  */
12
13 #include "vmlinux.h"
14 #include "net_shared.h"
15 #include <bpf/bpf_helpers.h>
16 #include <string.h>
17
18 # define printk(fmt, ...)                                               \
19                 ({                                                      \
20                         char ____fmt[] = fmt;                           \
21                         bpf_trace_printk(____fmt, sizeof(____fmt),      \
22                                      ##__VA_ARGS__);                    \
23                 })
24
25 #define CB_MAGIC 1234
26
27 /* Test: Pass all packets through */
28 SEC("nop")
29 int do_nop(struct __sk_buff *skb)
30 {
31         return BPF_OK;
32 }
33
34 /* Test: Verify context information can be accessed */
35 SEC("test_ctx")
36 int do_test_ctx(struct __sk_buff *skb)
37 {
38         skb->cb[0] = CB_MAGIC;
39         printk("len %d hash %d protocol %d", skb->len, skb->hash,
40                skb->protocol);
41         printk("cb %d ingress_ifindex %d ifindex %d", skb->cb[0],
42                skb->ingress_ifindex, skb->ifindex);
43
44         return BPF_OK;
45 }
46
47 /* Test: Ensure skb->cb[] buffer is cleared */
48 SEC("test_cb")
49 int do_test_cb(struct __sk_buff *skb)
50 {
51         printk("cb0: %x cb1: %x cb2: %x", skb->cb[0], skb->cb[1],
52                skb->cb[2]);
53         printk("cb3: %x cb4: %x", skb->cb[3], skb->cb[4]);
54
55         return BPF_OK;
56 }
57
58 /* Test: Verify skb data can be read */
59 SEC("test_data")
60 int do_test_data(struct __sk_buff *skb)
61 {
62         void *data = (void *)(long)skb->data;
63         void *data_end = (void *)(long)skb->data_end;
64         struct iphdr *iph = data;
65
66         if (data + sizeof(*iph) > data_end) {
67                 printk("packet truncated");
68                 return BPF_DROP;
69         }
70
71         printk("src: %x dst: %x", iph->saddr, iph->daddr);
72
73         return BPF_OK;
74 }
75
76 #define IP_CSUM_OFF offsetof(struct iphdr, check)
77 #define IP_DST_OFF offsetof(struct iphdr, daddr)
78 #define IP_SRC_OFF offsetof(struct iphdr, saddr)
79 #define IP_PROTO_OFF offsetof(struct iphdr, protocol)
80 #define TCP_CSUM_OFF offsetof(struct tcphdr, check)
81 #define UDP_CSUM_OFF offsetof(struct udphdr, check)
82 #define IS_PSEUDO 0x10
83
84 static inline int rewrite(struct __sk_buff *skb, uint32_t old_ip,
85                           uint32_t new_ip, int rw_daddr)
86 {
87         int ret, off = 0, flags = IS_PSEUDO;
88         uint8_t proto;
89
90         ret = bpf_skb_load_bytes(skb, IP_PROTO_OFF, &proto, 1);
91         if (ret < 0) {
92                 printk("bpf_l4_csum_replace failed: %d", ret);
93                 return BPF_DROP;
94         }
95
96         switch (proto) {
97         case IPPROTO_TCP:
98                 off = TCP_CSUM_OFF;
99                 break;
100
101         case IPPROTO_UDP:
102                 off = UDP_CSUM_OFF;
103                 flags |= BPF_F_MARK_MANGLED_0;
104                 break;
105
106         case IPPROTO_ICMPV6:
107                 off = offsetof(struct icmp6hdr, icmp6_cksum);
108                 break;
109         }
110
111         if (off) {
112                 ret = bpf_l4_csum_replace(skb, off, old_ip, new_ip,
113                                           flags | sizeof(new_ip));
114                 if (ret < 0) {
115                         printk("bpf_l4_csum_replace failed: %d");
116                         return BPF_DROP;
117                 }
118         }
119
120         ret = bpf_l3_csum_replace(skb, IP_CSUM_OFF, old_ip, new_ip, sizeof(new_ip));
121         if (ret < 0) {
122                 printk("bpf_l3_csum_replace failed: %d", ret);
123                 return BPF_DROP;
124         }
125
126         if (rw_daddr)
127                 ret = bpf_skb_store_bytes(skb, IP_DST_OFF, &new_ip, sizeof(new_ip), 0);
128         else
129                 ret = bpf_skb_store_bytes(skb, IP_SRC_OFF, &new_ip, sizeof(new_ip), 0);
130
131         if (ret < 0) {
132                 printk("bpf_skb_store_bytes() failed: %d", ret);
133                 return BPF_DROP;
134         }
135
136         return BPF_OK;
137 }
138
139 /* Test: Verify skb data can be modified */
140 SEC("test_rewrite")
141 int do_test_rewrite(struct __sk_buff *skb)
142 {
143         uint32_t old_ip, new_ip = 0x3fea8c0;
144         int ret;
145
146         ret = bpf_skb_load_bytes(skb, IP_DST_OFF, &old_ip, 4);
147         if (ret < 0) {
148                 printk("bpf_skb_load_bytes failed: %d", ret);
149                 return BPF_DROP;
150         }
151
152         if (old_ip == 0x2fea8c0) {
153                 printk("out: rewriting from %x to %x", old_ip, new_ip);
154                 return rewrite(skb, old_ip, new_ip, 1);
155         }
156
157         return BPF_OK;
158 }
159
160 static inline int __do_push_ll_and_redirect(struct __sk_buff *skb)
161 {
162         uint64_t smac = SRC_MAC, dmac = DST_MAC;
163         int ret, ifindex = DST_IFINDEX;
164         struct ethhdr ehdr;
165
166         ret = bpf_skb_change_head(skb, 14, 0);
167         if (ret < 0) {
168                 printk("skb_change_head() failed: %d", ret);
169         }
170
171         ehdr.h_proto = bpf_htons(ETH_P_IP);
172         memcpy(&ehdr.h_source, &smac, 6);
173         memcpy(&ehdr.h_dest, &dmac, 6);
174
175         ret = bpf_skb_store_bytes(skb, 0, &ehdr, sizeof(ehdr), 0);
176         if (ret < 0) {
177                 printk("skb_store_bytes() failed: %d", ret);
178                 return BPF_DROP;
179         }
180
181         return bpf_redirect(ifindex, 0);
182 }
183
184 SEC("push_ll_and_redirect_silent")
185 int do_push_ll_and_redirect_silent(struct __sk_buff *skb)
186 {
187         return __do_push_ll_and_redirect(skb);
188 }
189
190 SEC("push_ll_and_redirect")
191 int do_push_ll_and_redirect(struct __sk_buff *skb)
192 {
193         int ret, ifindex = DST_IFINDEX;
194
195         ret = __do_push_ll_and_redirect(skb);
196         if (ret >= 0)
197                 printk("redirected to %d", ifindex);
198
199         return ret;
200 }
201
202 static inline void __fill_garbage(struct __sk_buff *skb)
203 {
204         uint64_t f = 0xFFFFFFFFFFFFFFFF;
205
206         bpf_skb_store_bytes(skb, 0, &f, sizeof(f), 0);
207         bpf_skb_store_bytes(skb, 8, &f, sizeof(f), 0);
208         bpf_skb_store_bytes(skb, 16, &f, sizeof(f), 0);
209         bpf_skb_store_bytes(skb, 24, &f, sizeof(f), 0);
210         bpf_skb_store_bytes(skb, 32, &f, sizeof(f), 0);
211         bpf_skb_store_bytes(skb, 40, &f, sizeof(f), 0);
212         bpf_skb_store_bytes(skb, 48, &f, sizeof(f), 0);
213         bpf_skb_store_bytes(skb, 56, &f, sizeof(f), 0);
214         bpf_skb_store_bytes(skb, 64, &f, sizeof(f), 0);
215         bpf_skb_store_bytes(skb, 72, &f, sizeof(f), 0);
216         bpf_skb_store_bytes(skb, 80, &f, sizeof(f), 0);
217         bpf_skb_store_bytes(skb, 88, &f, sizeof(f), 0);
218 }
219
220 SEC("fill_garbage")
221 int do_fill_garbage(struct __sk_buff *skb)
222 {
223         __fill_garbage(skb);
224         printk("Set initial 96 bytes of header to FF");
225         return BPF_OK;
226 }
227
228 SEC("fill_garbage_and_redirect")
229 int do_fill_garbage_and_redirect(struct __sk_buff *skb)
230 {
231         int ifindex = DST_IFINDEX;
232         __fill_garbage(skb);
233         printk("redirected to %d", ifindex);
234         return bpf_redirect(ifindex, 0);
235 }
236
237 /* Drop all packets */
238 SEC("drop_all")
239 int do_drop_all(struct __sk_buff *skb)
240 {
241         printk("dropping with: %d", BPF_DROP);
242         return BPF_DROP;
243 }
244
245 char _license[] SEC("license") = "GPL";