xref: /linux/tools/testing/selftests/bpf/progs/exceptions_assert.c (revision 993498e537af9260e697219ce41b41b22b6199cc)
1 // SPDX-License-Identifier: GPL-2.0
2 #include <vmlinux.h>
3 #include <limits.h>
4 #include <bpf/bpf_tracing.h>
5 #include <bpf/bpf_helpers.h>
6 #include <bpf/bpf_core_read.h>
7 #include <bpf/bpf_endian.h>
8 #include "bpf_misc.h"
9 #include "bpf_experimental.h"
10 
11 #define check_assert(type, op, name, value)				\
12 	SEC("?tc")							\
13 	__log_level(2) __failure					\
14 	int check_assert_##op##_##name(void *ctx)			\
15 	{								\
16 		type num = bpf_ktime_get_ns();				\
17 		bpf_assert_##op(num, value);				\
18 		return *(u64 *)num;					\
19 	}
20 
21 __msg(": R0_w=0xffffffff80000000 R10=fp0")
22 check_assert(s64, eq, int_min, INT_MIN);
23 __msg(": R0_w=0x7fffffff R10=fp0")
24 check_assert(s64, eq, int_max, INT_MAX);
25 __msg(": R0_w=0 R10=fp0")
26 check_assert(s64, eq, zero, 0);
27 __msg(": R0_w=0x8000000000000000 R1_w=0x8000000000000000 R10=fp0")
28 check_assert(s64, eq, llong_min, LLONG_MIN);
29 __msg(": R0_w=0x7fffffffffffffff R1_w=0x7fffffffffffffff R10=fp0")
30 check_assert(s64, eq, llong_max, LLONG_MAX);
31 
32 __msg(": R0_w=scalar(smax=0x7ffffffe) R10=fp0")
33 check_assert(s64, lt, pos, INT_MAX);
34 __msg(": R0_w=scalar(smax=-1,umin=0x8000000000000000,var_off=(0x8000000000000000; 0x7fffffffffffffff))")
35 check_assert(s64, lt, zero, 0);
36 __msg(": R0_w=scalar(smax=0xffffffff7fffffff,umin=0x8000000000000000,umax=0xffffffff7fffffff,var_off=(0x8000000000000000; 0x7fffffffffffffff))")
37 check_assert(s64, lt, neg, INT_MIN);
38 
39 __msg(": R0_w=scalar(smax=0x7fffffff) R10=fp0")
40 check_assert(s64, le, pos, INT_MAX);
41 __msg(": R0_w=scalar(smax=0) R10=fp0")
42 check_assert(s64, le, zero, 0);
43 __msg(": R0_w=scalar(smax=0xffffffff80000000,umin=0x8000000000000000,umax=0xffffffff80000000,var_off=(0x8000000000000000; 0x7fffffffffffffff))")
44 check_assert(s64, le, neg, INT_MIN);
45 
46 __msg(": R0_w=scalar(smin=umin=0x80000000,umax=0x7fffffffffffffff,var_off=(0x0; 0x7fffffffffffffff))")
47 check_assert(s64, gt, pos, INT_MAX);
48 __msg(": R0_w=scalar(smin=umin=1,umax=0x7fffffffffffffff,var_off=(0x0; 0x7fffffffffffffff))")
49 check_assert(s64, gt, zero, 0);
50 __msg(": R0_w=scalar(smin=0xffffffff80000001) R10=fp0")
51 check_assert(s64, gt, neg, INT_MIN);
52 
53 __msg(": R0_w=scalar(smin=umin=0x7fffffff,umax=0x7fffffffffffffff,var_off=(0x0; 0x7fffffffffffffff))")
54 check_assert(s64, ge, pos, INT_MAX);
55 __msg(": R0_w=scalar(smin=0,umax=0x7fffffffffffffff,var_off=(0x0; 0x7fffffffffffffff)) R10=fp0")
56 check_assert(s64, ge, zero, 0);
57 __msg(": R0_w=scalar(smin=0xffffffff80000000) R10=fp0")
58 check_assert(s64, ge, neg, INT_MIN);
59 
60 SEC("?tc")
61 __log_level(2) __failure
62 __msg(": R0=0 R1=ctx() R2=scalar(smin=0xffffffff80000002,smax=smax32=0x7ffffffd,smin32=0x80000002) R10=fp0")
63 int check_assert_range_s64(struct __sk_buff *ctx)
64 {
65 	struct bpf_sock *sk = ctx->sk;
66 	s64 num;
67 
68 	_Static_assert(_Generic((sk->rx_queue_mapping), s32: 1, default: 0), "type match");
69 	if (!sk)
70 		return 0;
71 	num = sk->rx_queue_mapping;
72 	bpf_assert_range(num, INT_MIN + 2, INT_MAX - 2);
73 	return *((u8 *)ctx + num);
74 }
75 
76 SEC("?tc")
77 __log_level(2) __failure
78 __msg(": R1=ctx() R2=scalar(smin=umin=smin32=umin32=4096,smax=umax=smax32=umax32=8192,var_off=(0x0; 0x3fff))")
79 int check_assert_range_u64(struct __sk_buff *ctx)
80 {
81 	u64 num = ctx->len;
82 
83 	bpf_assert_range(num, 4096, 8192);
84 	return *((u8 *)ctx + num);
85 }
86 
87 SEC("?tc")
88 __log_level(2) __failure
89 __msg(": R0=0 R1=ctx() R2=4096 R10=fp0")
90 int check_assert_single_range_s64(struct __sk_buff *ctx)
91 {
92 	struct bpf_sock *sk = ctx->sk;
93 	s64 num;
94 
95 	_Static_assert(_Generic((sk->rx_queue_mapping), s32: 1, default: 0), "type match");
96 	if (!sk)
97 		return 0;
98 	num = sk->rx_queue_mapping;
99 
100 	bpf_assert_range(num, 4096, 4096);
101 	return *((u8 *)ctx + num);
102 }
103 
104 SEC("?tc")
105 __log_level(2) __failure
106 __msg(": R1=ctx() R2=4096 R10=fp0")
107 int check_assert_single_range_u64(struct __sk_buff *ctx)
108 {
109 	u64 num = ctx->len;
110 
111 	bpf_assert_range(num, 4096, 4096);
112 	return *((u8 *)ctx + num);
113 }
114 
115 SEC("?tc")
116 __log_level(2) __failure
117 __msg(": R1=pkt(off=64,r=64) R2=pkt_end() R6=pkt(r=64) R10=fp0")
118 int check_assert_generic(struct __sk_buff *ctx)
119 {
120 	u8 *data_end = (void *)(long)ctx->data_end;
121 	u8 *data = (void *)(long)ctx->data;
122 
123 	bpf_assert(data + 64 <= data_end);
124 	return data[128];
125 }
126 
127 SEC("?fentry/bpf_check")
128 __failure __msg("At program exit the register R1 has smin=64 smax=64")
129 int check_assert_with_return(void *ctx)
130 {
131 	bpf_assert_with(!ctx, 64);
132 	return 0;
133 }
134 
135 char _license[] SEC("license") = "GPL";
136