1 // SPDX-License-Identifier: GPL-2.0
2 /* Converted from tools/testing/selftests/bpf/verifier/meta_access.c */
3
4 #include <linux/bpf.h>
5 #include <bpf/bpf_helpers.h>
6 #include "bpf_misc.h"
7
8 SEC("xdp")
9 __description("meta access, test1")
10 __success __retval(0)
meta_access_test1(void)11 __naked void meta_access_test1(void)
12 {
13 asm volatile (" \
14 r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \
15 r3 = *(u32*)(r1 + %[xdp_md_data]); \
16 r0 = r2; \
17 r0 += 8; \
18 if r0 > r3 goto l0_%=; \
19 r0 = *(u8*)(r2 + 0); \
20 l0_%=: r0 = 0; \
21 exit; \
22 " :
23 : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
24 __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
25 : __clobber_all);
26 }
27
28 SEC("xdp")
29 __description("meta access, test2")
30 __failure __msg("invalid access to packet, off=-8")
meta_access_test2(void)31 __naked void meta_access_test2(void)
32 {
33 asm volatile (" \
34 r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \
35 r3 = *(u32*)(r1 + %[xdp_md_data]); \
36 r0 = r2; \
37 r0 -= 8; \
38 r4 = r2; \
39 r4 += 8; \
40 if r4 > r3 goto l0_%=; \
41 r0 = *(u8*)(r0 + 0); \
42 l0_%=: r0 = 0; \
43 exit; \
44 " :
45 : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
46 __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
47 : __clobber_all);
48 }
49
50 SEC("xdp")
51 __description("meta access, test3")
52 __failure __msg("invalid access to packet")
meta_access_test3(void)53 __naked void meta_access_test3(void)
54 {
55 asm volatile (" \
56 r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \
57 r3 = *(u32*)(r1 + %[xdp_md_data_end]); \
58 r0 = r2; \
59 r0 += 8; \
60 if r0 > r3 goto l0_%=; \
61 r0 = *(u8*)(r2 + 0); \
62 l0_%=: r0 = 0; \
63 exit; \
64 " :
65 : __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)),
66 __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
67 : __clobber_all);
68 }
69
70 SEC("xdp")
71 __description("meta access, test4")
72 __failure __msg("invalid access to packet")
meta_access_test4(void)73 __naked void meta_access_test4(void)
74 {
75 asm volatile (" \
76 r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \
77 r3 = *(u32*)(r1 + %[xdp_md_data_end]); \
78 r4 = *(u32*)(r1 + %[xdp_md_data]); \
79 r0 = r4; \
80 r0 += 8; \
81 if r0 > r3 goto l0_%=; \
82 r0 = *(u8*)(r2 + 0); \
83 l0_%=: r0 = 0; \
84 exit; \
85 " :
86 : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
87 __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)),
88 __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
89 : __clobber_all);
90 }
91
92 SEC("xdp")
93 __description("meta access, test5")
94 __failure __msg("R3 !read_ok")
meta_access_test5(void)95 __naked void meta_access_test5(void)
96 {
97 asm volatile (" \
98 r3 = *(u32*)(r1 + %[xdp_md_data_meta]); \
99 r4 = *(u32*)(r1 + %[xdp_md_data]); \
100 r0 = r3; \
101 r0 += 8; \
102 if r0 > r4 goto l0_%=; \
103 r2 = -8; \
104 call %[bpf_xdp_adjust_meta]; \
105 r0 = *(u8*)(r3 + 0); \
106 l0_%=: r0 = 0; \
107 exit; \
108 " :
109 : __imm(bpf_xdp_adjust_meta),
110 __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
111 __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
112 : __clobber_all);
113 }
114
115 SEC("xdp")
116 __description("meta access, test6")
117 __failure __msg("invalid access to packet")
meta_access_test6(void)118 __naked void meta_access_test6(void)
119 {
120 asm volatile (" \
121 r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \
122 r3 = *(u32*)(r1 + %[xdp_md_data]); \
123 r0 = r3; \
124 r0 += 8; \
125 r4 = r2; \
126 r4 += 8; \
127 if r4 > r0 goto l0_%=; \
128 r0 = *(u8*)(r2 + 0); \
129 l0_%=: r0 = 0; \
130 exit; \
131 " :
132 : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
133 __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
134 : __clobber_all);
135 }
136
137 SEC("xdp")
138 __description("meta access, test7")
139 __success __retval(0)
meta_access_test7(void)140 __naked void meta_access_test7(void)
141 {
142 asm volatile (" \
143 r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \
144 r3 = *(u32*)(r1 + %[xdp_md_data]); \
145 r0 = r3; \
146 r0 += 8; \
147 r4 = r2; \
148 r4 += 8; \
149 if r4 > r3 goto l0_%=; \
150 r0 = *(u8*)(r2 + 0); \
151 l0_%=: r0 = 0; \
152 exit; \
153 " :
154 : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
155 __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
156 : __clobber_all);
157 }
158
159 SEC("xdp")
160 __description("meta access, test8")
161 __success __retval(0)
meta_access_test8(void)162 __naked void meta_access_test8(void)
163 {
164 asm volatile (" \
165 r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \
166 r3 = *(u32*)(r1 + %[xdp_md_data]); \
167 r4 = r2; \
168 r4 += 0xFFFF; \
169 if r4 > r3 goto l0_%=; \
170 r0 = *(u8*)(r2 + 0); \
171 l0_%=: r0 = 0; \
172 exit; \
173 " :
174 : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
175 __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
176 : __clobber_all);
177 }
178
179 SEC("xdp")
180 __description("meta access, test9")
181 __failure __msg("invalid access to packet")
meta_access_test9(void)182 __naked void meta_access_test9(void)
183 {
184 asm volatile (" \
185 r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \
186 r3 = *(u32*)(r1 + %[xdp_md_data]); \
187 r4 = r2; \
188 r4 += 0xFFFF; \
189 r4 += 1; \
190 if r4 > r3 goto l0_%=; \
191 r0 = *(u8*)(r2 + 0); \
192 l0_%=: r0 = 0; \
193 exit; \
194 " :
195 : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
196 __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
197 : __clobber_all);
198 }
199
200 SEC("xdp")
201 __description("meta access, test10")
202 __failure __msg("invalid access to packet")
meta_access_test10(void)203 __naked void meta_access_test10(void)
204 {
205 asm volatile (" \
206 r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \
207 r3 = *(u32*)(r1 + %[xdp_md_data]); \
208 r4 = *(u32*)(r1 + %[xdp_md_data_end]); \
209 r5 = 42; \
210 r6 = 24; \
211 *(u64*)(r10 - 8) = r5; \
212 lock *(u64 *)(r10 - 8) += r6; \
213 r5 = *(u64*)(r10 - 8); \
214 if r5 > 100 goto l0_%=; \
215 r3 += r5; \
216 r5 = r3; \
217 r6 = r2; \
218 r6 += 8; \
219 if r6 > r5 goto l0_%=; \
220 r2 = *(u8*)(r2 + 0); \
221 l0_%=: r0 = 0; \
222 exit; \
223 " :
224 : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
225 __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)),
226 __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
227 : __clobber_all);
228 }
229
230 SEC("xdp")
231 __description("meta access, test11")
232 __success __retval(0)
meta_access_test11(void)233 __naked void meta_access_test11(void)
234 {
235 asm volatile (" \
236 r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \
237 r3 = *(u32*)(r1 + %[xdp_md_data]); \
238 r5 = 42; \
239 r6 = 24; \
240 *(u64*)(r10 - 8) = r5; \
241 lock *(u64 *)(r10 - 8) += r6; \
242 r5 = *(u64*)(r10 - 8); \
243 if r5 > 100 goto l0_%=; \
244 r2 += r5; \
245 r5 = r2; \
246 r6 = r2; \
247 r6 += 8; \
248 if r6 > r3 goto l0_%=; \
249 r5 = *(u8*)(r5 + 0); \
250 l0_%=: r0 = 0; \
251 exit; \
252 " :
253 : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
254 __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
255 : __clobber_all);
256 }
257
258 SEC("xdp")
259 __description("meta access, test12")
260 __success __retval(0)
meta_access_test12(void)261 __naked void meta_access_test12(void)
262 {
263 asm volatile (" \
264 r2 = *(u32*)(r1 + %[xdp_md_data_meta]); \
265 r3 = *(u32*)(r1 + %[xdp_md_data]); \
266 r4 = *(u32*)(r1 + %[xdp_md_data_end]); \
267 r5 = r3; \
268 r5 += 16; \
269 if r5 > r4 goto l0_%=; \
270 r0 = *(u8*)(r3 + 0); \
271 r5 = r2; \
272 r5 += 16; \
273 if r5 > r3 goto l0_%=; \
274 r0 = *(u8*)(r2 + 0); \
275 l0_%=: r0 = 0; \
276 exit; \
277 " :
278 : __imm_const(xdp_md_data, offsetof(struct xdp_md, data)),
279 __imm_const(xdp_md_data_end, offsetof(struct xdp_md, data_end)),
280 __imm_const(xdp_md_data_meta, offsetof(struct xdp_md, data_meta))
281 : __clobber_all);
282 }
283
284 char _license[] SEC("license") = "GPL";
285