tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
selftests/bpf: Mark tests that require unaligned memory access
A lot of tests require unaligned memory access to work. Mark the tests
as such, so that they can be avoided on unsupported architectures such
as RISC-V.
Signed-off-by: Björn Töpel <bjorn.topel@gmail.com>
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Acked-by: Luke Nelson <luke.r.nels@gmail.com>
Link: https://lore.kernel.org/bpf/20201118071640.83773-4-bjorn.topel@gmail.com
authored by
Björn Töpel
and committed by
Andrii Nakryiko
6007b23c
c77b0589
+52
-18
+7
tools/testing/selftests/bpf/verifier/ctx_sk_lookup.c
+7
tools/testing/selftests/bpf/verifier/ctx_sk_lookup.c
···
266
266
.result = REJECT,
267
267
.prog_type = BPF_PROG_TYPE_SK_LOOKUP,
268
268
.expected_attach_type = BPF_SK_LOOKUP,
269
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
269
270
},
270
271
{
271
272
"invalid 8-byte read from bpf_sk_lookup remote_ip4 field",
···
293
292
.result = REJECT,
294
293
.prog_type = BPF_PROG_TYPE_SK_LOOKUP,
295
294
.expected_attach_type = BPF_SK_LOOKUP,
295
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
296
296
},
297
297
{
298
298
"invalid 8-byte read from bpf_sk_lookup remote_port field",
···
307
305
.result = REJECT,
308
306
.prog_type = BPF_PROG_TYPE_SK_LOOKUP,
309
307
.expected_attach_type = BPF_SK_LOOKUP,
308
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
310
309
},
311
310
{
312
311
"invalid 8-byte read from bpf_sk_lookup local_ip4 field",
···
334
331
.result = REJECT,
335
332
.prog_type = BPF_PROG_TYPE_SK_LOOKUP,
336
333
.expected_attach_type = BPF_SK_LOOKUP,
334
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
337
335
},
338
336
{
339
337
"invalid 8-byte read from bpf_sk_lookup local_port field",
···
348
344
.result = REJECT,
349
345
.prog_type = BPF_PROG_TYPE_SK_LOOKUP,
350
346
.expected_attach_type = BPF_SK_LOOKUP,
347
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
351
348
},
352
349
/* invalid 1,2,4-byte reads from 8-byte fields in bpf_sk_lookup */
353
350
{
···
415
410
.result = REJECT,
416
411
.prog_type = BPF_PROG_TYPE_SK_LOOKUP,
417
412
.expected_attach_type = BPF_SK_LOOKUP,
413
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
418
414
},
419
415
{
420
416
"invalid 4-byte unaligned read from bpf_sk_lookup at even offset",
···
428
422
.result = REJECT,
429
423
.prog_type = BPF_PROG_TYPE_SK_LOOKUP,
430
424
.expected_attach_type = BPF_SK_LOOKUP,
425
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
431
426
},
432
427
/* in-bound and out-of-bound writes to bpf_sk_lookup */
433
428
{
+3
tools/testing/selftests/bpf/verifier/direct_value_access.c
+3
tools/testing/selftests/bpf/verifier/direct_value_access.c
···
69
69
.fixup_map_array_48b = { 1 },
70
70
.result = REJECT,
71
71
.errstr = "R1 min value is outside of the allowed memory range",
72
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
72
73
},
73
74
{
74
75
"direct map access, write test 7",
···
196
195
.fixup_map_array_48b = { 1, 3 },
197
196
.result = REJECT,
198
197
.errstr = "invalid access to map value, value_size=48 off=47 size=2",
198
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
199
199
},
200
200
{
201
201
"direct map access, write test 17",
···
211
209
.fixup_map_array_48b = { 1, 3 },
212
210
.result = REJECT,
213
211
.errstr = "invalid access to map value, value_size=48 off=47 size=2",
212
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
214
213
},
215
214
{
216
215
"direct map access, write test 18",
+1
tools/testing/selftests/bpf/verifier/map_ptr.c
+1
tools/testing/selftests/bpf/verifier/map_ptr.c
···
44
44
.errstr_unpriv = "bpf_array access is allowed only to CAP_PERFMON and CAP_SYS_ADMIN",
45
45
.result = REJECT,
46
46
.errstr = "cannot access ptr member ops with moff 0 in struct bpf_map with off 1 size 4",
47
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
47
48
},
48
49
{
49
50
"bpf_map_ptr: read ops field accepted",
+1
tools/testing/selftests/bpf/verifier/raw_tp_writable.c
+1
tools/testing/selftests/bpf/verifier/raw_tp_writable.c
+4
tools/testing/selftests/bpf/verifier/ref_tracking.c
+4
tools/testing/selftests/bpf/verifier/ref_tracking.c
···
675
675
.prog_type = BPF_PROG_TYPE_SCHED_CLS,
676
676
.result = REJECT,
677
677
.errstr = "invalid mem access",
678
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
678
679
},
679
680
{
680
681
"reference tracking: use ptr from bpf_sk_fullsock() after release",
···
699
698
.prog_type = BPF_PROG_TYPE_SCHED_CLS,
700
699
.result = REJECT,
701
700
.errstr = "invalid mem access",
701
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
702
702
},
703
703
{
704
704
"reference tracking: use ptr from bpf_sk_fullsock(tp) after release",
···
727
725
.prog_type = BPF_PROG_TYPE_SCHED_CLS,
728
726
.result = REJECT,
729
727
.errstr = "invalid mem access",
728
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
730
729
},
731
730
{
732
731
"reference tracking: use sk after bpf_sk_release(tp)",
···
750
747
.prog_type = BPF_PROG_TYPE_SCHED_CLS,
751
748
.result = REJECT,
752
749
.errstr = "invalid mem access",
750
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
753
751
},
754
752
{
755
753
"reference tracking: use ptr from bpf_get_listener_sock() after bpf_sk_release(sk)",
+8
tools/testing/selftests/bpf/verifier/regalloc.c
+8
tools/testing/selftests/bpf/verifier/regalloc.c
···
21
21
.fixup_map_hash_48b = { 4 },
22
22
.result = ACCEPT,
23
23
.prog_type = BPF_PROG_TYPE_TRACEPOINT,
24
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
24
25
},
25
26
{
26
27
"regalloc negative",
···
72
71
.fixup_map_hash_48b = { 4 },
73
72
.result = ACCEPT,
74
73
.prog_type = BPF_PROG_TYPE_TRACEPOINT,
74
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
75
75
},
76
76
{
77
77
"regalloc src_reg negative",
···
99
97
.result = REJECT,
100
98
.errstr = "invalid access to map value, value_size=48 off=44 size=8",
101
99
.prog_type = BPF_PROG_TYPE_TRACEPOINT,
100
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
102
101
},
103
102
{
104
103
"regalloc and spill",
···
129
126
.fixup_map_hash_48b = { 4 },
130
127
.result = ACCEPT,
131
128
.prog_type = BPF_PROG_TYPE_TRACEPOINT,
129
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
132
130
},
133
131
{
134
132
"regalloc and spill negative",
···
160
156
.result = REJECT,
161
157
.errstr = "invalid access to map value, value_size=48 off=48 size=8",
162
158
.prog_type = BPF_PROG_TYPE_TRACEPOINT,
159
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
163
160
},
164
161
{
165
162
"regalloc three regs",
···
187
182
.fixup_map_hash_48b = { 4 },
188
183
.result = ACCEPT,
189
184
.prog_type = BPF_PROG_TYPE_TRACEPOINT,
185
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
190
186
},
191
187
{
192
188
"regalloc after call",
···
216
210
.fixup_map_hash_48b = { 4 },
217
211
.result = ACCEPT,
218
212
.prog_type = BPF_PROG_TYPE_TRACEPOINT,
213
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
219
214
},
220
215
{
221
216
"regalloc in callee",
···
247
240
.fixup_map_hash_48b = { 4 },
248
241
.result = ACCEPT,
249
242
.prog_type = BPF_PROG_TYPE_TRACEPOINT,
243
+
.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
250
244
},
251
245
{
252
246
"regalloc, spill, JEQ",
+28
-18
tools/testing/selftests/bpf/verifier/wide_access.c
+28
-18
tools/testing/selftests/bpf/verifier/wide_access.c
···
1
-
#define BPF_SOCK_ADDR_STORE(field, off, res, err) \
1
+
#define BPF_SOCK_ADDR_STORE(field, off, res, err, flgs) \
2
2
{ \
3
3
"wide store to bpf_sock_addr." #field "[" #off "]", \
4
4
.insns = { \
···
11
11
.prog_type = BPF_PROG_TYPE_CGROUP_SOCK_ADDR, \
12
12
.expected_attach_type = BPF_CGROUP_UDP6_SENDMSG, \
13
13
.errstr = err, \
14
+
.flags = flgs, \
14
15
}
15
16
16
17
/* user_ip6[0] is u64 aligned */
17
18
BPF_SOCK_ADDR_STORE(user_ip6, 0, ACCEPT,
18
-
NULL),
19
+
NULL, 0),
19
20
BPF_SOCK_ADDR_STORE(user_ip6, 1, REJECT,
20
-
"invalid bpf_context access off=12 size=8"),
21
+
"invalid bpf_context access off=12 size=8",
22
+
F_NEEDS_EFFICIENT_UNALIGNED_ACCESS),
21
23
BPF_SOCK_ADDR_STORE(user_ip6, 2, ACCEPT,
22
-
NULL),
24
+
NULL, 0),
23
25
BPF_SOCK_ADDR_STORE(user_ip6, 3, REJECT,
24
-
"invalid bpf_context access off=20 size=8"),
26
+
"invalid bpf_context access off=20 size=8",
27
+
F_NEEDS_EFFICIENT_UNALIGNED_ACCESS),
25
28
26
29
/* msg_src_ip6[0] is _not_ u64 aligned */
27
30
BPF_SOCK_ADDR_STORE(msg_src_ip6, 0, REJECT,
28
-
"invalid bpf_context access off=44 size=8"),
31
+
"invalid bpf_context access off=44 size=8",
32
+
F_NEEDS_EFFICIENT_UNALIGNED_ACCESS),
29
33
BPF_SOCK_ADDR_STORE(msg_src_ip6, 1, ACCEPT,
30
-
NULL),
34
+
NULL, 0),
31
35
BPF_SOCK_ADDR_STORE(msg_src_ip6, 2, REJECT,
32
-
"invalid bpf_context access off=52 size=8"),
36
+
"invalid bpf_context access off=52 size=8",
37
+
F_NEEDS_EFFICIENT_UNALIGNED_ACCESS),
33
38
BPF_SOCK_ADDR_STORE(msg_src_ip6, 3, REJECT,
34
-
"invalid bpf_context access off=56 size=8"),
39
+
"invalid bpf_context access off=56 size=8", 0),
35
40
36
41
#undef BPF_SOCK_ADDR_STORE
37
42
38
-
#define BPF_SOCK_ADDR_LOAD(field, off, res, err) \
43
+
#define BPF_SOCK_ADDR_LOAD(field, off, res, err, flgs) \
39
44
{ \
40
45
"wide load from bpf_sock_addr." #field "[" #off "]", \
41
46
.insns = { \
···
53
48
.prog_type = BPF_PROG_TYPE_CGROUP_SOCK_ADDR, \
54
49
.expected_attach_type = BPF_CGROUP_UDP6_SENDMSG, \
55
50
.errstr = err, \
51
+
.flags = flgs, \
56
52
}
57
53
58
54
/* user_ip6[0] is u64 aligned */
59
55
BPF_SOCK_ADDR_LOAD(user_ip6, 0, ACCEPT,
60
-
NULL),
56
+
NULL, 0),
61
57
BPF_SOCK_ADDR_LOAD(user_ip6, 1, REJECT,
62
-
"invalid bpf_context access off=12 size=8"),
58
+
"invalid bpf_context access off=12 size=8",
59
+
F_NEEDS_EFFICIENT_UNALIGNED_ACCESS),
63
60
BPF_SOCK_ADDR_LOAD(user_ip6, 2, ACCEPT,
64
-
NULL),
61
+
NULL, 0),
65
62
BPF_SOCK_ADDR_LOAD(user_ip6, 3, REJECT,
66
-
"invalid bpf_context access off=20 size=8"),
63
+
"invalid bpf_context access off=20 size=8",
64
+
F_NEEDS_EFFICIENT_UNALIGNED_ACCESS),
67
65
68
66
/* msg_src_ip6[0] is _not_ u64 aligned */
69
67
BPF_SOCK_ADDR_LOAD(msg_src_ip6, 0, REJECT,
70
-
"invalid bpf_context access off=44 size=8"),
68
+
"invalid bpf_context access off=44 size=8",
69
+
F_NEEDS_EFFICIENT_UNALIGNED_ACCESS),
71
70
BPF_SOCK_ADDR_LOAD(msg_src_ip6, 1, ACCEPT,
72
-
NULL),
71
+
NULL, 0),
73
72
BPF_SOCK_ADDR_LOAD(msg_src_ip6, 2, REJECT,
74
-
"invalid bpf_context access off=52 size=8"),
73
+
"invalid bpf_context access off=52 size=8",
74
+
F_NEEDS_EFFICIENT_UNALIGNED_ACCESS),
75
75
BPF_SOCK_ADDR_LOAD(msg_src_ip6, 3, REJECT,
76
-
"invalid bpf_context access off=56 size=8"),
76
+
"invalid bpf_context access off=56 size=8", 0),
77
77
78
78
#undef BPF_SOCK_ADDR_LOAD