1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* Copyright (c) 2023 Meta Platforms, Inc. and affiliates. */ |
3 | |
4 | #include <limits.h> |
5 | #include <linux/errno.h> |
6 | #include "vmlinux.h" |
7 | #include <bpf/bpf_helpers.h> |
8 | #include "bpf_misc.h" |
9 | |
10 | const volatile __s64 exp_empty_zero = 0 + 1; |
11 | __s64 res_empty_zero; |
12 | |
13 | SEC("raw_tp/sys_enter" ) |
14 | int num_empty_zero(const void *ctx) |
15 | { |
16 | __s64 sum = 0, i; |
17 | |
18 | bpf_for(i, 0, 0) sum += i; |
19 | res_empty_zero = 1 + sum; |
20 | |
21 | return 0; |
22 | } |
23 | |
24 | const volatile __s64 exp_empty_int_min = 0 + 2; |
25 | __s64 res_empty_int_min; |
26 | |
27 | SEC("raw_tp/sys_enter" ) |
28 | int num_empty_int_min(const void *ctx) |
29 | { |
30 | __s64 sum = 0, i; |
31 | |
32 | bpf_for(i, INT_MIN, INT_MIN) sum += i; |
33 | res_empty_int_min = 2 + sum; |
34 | |
35 | return 0; |
36 | } |
37 | |
38 | const volatile __s64 exp_empty_int_max = 0 + 3; |
39 | __s64 res_empty_int_max; |
40 | |
41 | SEC("raw_tp/sys_enter" ) |
42 | int num_empty_int_max(const void *ctx) |
43 | { |
44 | __s64 sum = 0, i; |
45 | |
46 | bpf_for(i, INT_MAX, INT_MAX) sum += i; |
47 | res_empty_int_max = 3 + sum; |
48 | |
49 | return 0; |
50 | } |
51 | |
52 | const volatile __s64 exp_empty_minus_one = 0 + 4; |
53 | __s64 res_empty_minus_one; |
54 | |
55 | SEC("raw_tp/sys_enter" ) |
56 | int num_empty_minus_one(const void *ctx) |
57 | { |
58 | __s64 sum = 0, i; |
59 | |
60 | bpf_for(i, -1, -1) sum += i; |
61 | res_empty_minus_one = 4 + sum; |
62 | |
63 | return 0; |
64 | } |
65 | |
66 | const volatile __s64 exp_simple_sum = 9 * 10 / 2; |
67 | __s64 res_simple_sum; |
68 | |
69 | SEC("raw_tp/sys_enter" ) |
70 | int num_simple_sum(const void *ctx) |
71 | { |
72 | __s64 sum = 0, i; |
73 | |
74 | bpf_for(i, 0, 10) sum += i; |
75 | res_simple_sum = sum; |
76 | |
77 | return 0; |
78 | } |
79 | |
80 | const volatile __s64 exp_neg_sum = -11 * 10 / 2; |
81 | __s64 res_neg_sum; |
82 | |
83 | SEC("raw_tp/sys_enter" ) |
84 | int num_neg_sum(const void *ctx) |
85 | { |
86 | __s64 sum = 0, i; |
87 | |
88 | bpf_for(i, -10, 0) sum += i; |
89 | res_neg_sum = sum; |
90 | |
91 | return 0; |
92 | } |
93 | |
94 | const volatile __s64 exp_very_neg_sum = INT_MIN + (__s64)(INT_MIN + 1); |
95 | __s64 res_very_neg_sum; |
96 | |
97 | SEC("raw_tp/sys_enter" ) |
98 | int num_very_neg_sum(const void *ctx) |
99 | { |
100 | __s64 sum = 0, i; |
101 | |
102 | bpf_for(i, INT_MIN, INT_MIN + 2) sum += i; |
103 | res_very_neg_sum = sum; |
104 | |
105 | return 0; |
106 | } |
107 | |
108 | const volatile __s64 exp_very_big_sum = (__s64)(INT_MAX - 1) + (__s64)(INT_MAX - 2); |
109 | __s64 res_very_big_sum; |
110 | |
111 | SEC("raw_tp/sys_enter" ) |
112 | int num_very_big_sum(const void *ctx) |
113 | { |
114 | __s64 sum = 0, i; |
115 | |
116 | bpf_for(i, INT_MAX - 2, INT_MAX) sum += i; |
117 | res_very_big_sum = sum; |
118 | |
119 | return 0; |
120 | } |
121 | |
122 | const volatile __s64 exp_neg_pos_sum = -3; |
123 | __s64 res_neg_pos_sum; |
124 | |
125 | SEC("raw_tp/sys_enter" ) |
126 | int num_neg_pos_sum(const void *ctx) |
127 | { |
128 | __s64 sum = 0, i; |
129 | |
130 | bpf_for(i, -3, 3) sum += i; |
131 | res_neg_pos_sum = sum; |
132 | |
133 | return 0; |
134 | } |
135 | |
136 | const volatile __s64 exp_invalid_range = -EINVAL; |
137 | __s64 res_invalid_range; |
138 | |
139 | SEC("raw_tp/sys_enter" ) |
140 | int num_invalid_range(const void *ctx) |
141 | { |
142 | struct bpf_iter_num it; |
143 | |
144 | res_invalid_range = bpf_iter_num_new(&it, 1, 0); |
145 | bpf_iter_num_destroy(&it); |
146 | |
147 | return 0; |
148 | } |
149 | |
150 | const volatile __s64 exp_max_range = 0 + 10; |
151 | __s64 res_max_range; |
152 | |
153 | SEC("raw_tp/sys_enter" ) |
154 | int num_max_range(const void *ctx) |
155 | { |
156 | struct bpf_iter_num it; |
157 | |
158 | res_max_range = 10 + bpf_iter_num_new(&it, 0, BPF_MAX_LOOPS); |
159 | bpf_iter_num_destroy(&it); |
160 | |
161 | return 0; |
162 | } |
163 | |
164 | const volatile __s64 exp_e2big_range = -E2BIG; |
165 | __s64 res_e2big_range; |
166 | |
167 | SEC("raw_tp/sys_enter" ) |
168 | int num_e2big_range(const void *ctx) |
169 | { |
170 | struct bpf_iter_num it; |
171 | |
172 | res_e2big_range = bpf_iter_num_new(&it, -1, BPF_MAX_LOOPS); |
173 | bpf_iter_num_destroy(&it); |
174 | |
175 | return 0; |
176 | } |
177 | |
178 | const volatile __s64 exp_succ_elem_cnt = 10; |
179 | __s64 res_succ_elem_cnt; |
180 | |
181 | SEC("raw_tp/sys_enter" ) |
182 | int num_succ_elem_cnt(const void *ctx) |
183 | { |
184 | struct bpf_iter_num it; |
185 | int cnt = 0, *v; |
186 | |
187 | bpf_iter_num_new(&it, 0, 10); |
188 | while ((v = bpf_iter_num_next(&it))) { |
189 | cnt++; |
190 | } |
191 | bpf_iter_num_destroy(&it); |
192 | |
193 | res_succ_elem_cnt = cnt; |
194 | |
195 | return 0; |
196 | } |
197 | |
198 | const volatile __s64 exp_overfetched_elem_cnt = 5; |
199 | __s64 res_overfetched_elem_cnt; |
200 | |
201 | SEC("raw_tp/sys_enter" ) |
202 | int num_overfetched_elem_cnt(const void *ctx) |
203 | { |
204 | struct bpf_iter_num it; |
205 | int cnt = 0, *v, i; |
206 | |
207 | bpf_iter_num_new(&it, 0, 5); |
208 | for (i = 0; i < 10; i++) { |
209 | v = bpf_iter_num_next(&it); |
210 | if (v) |
211 | cnt++; |
212 | } |
213 | bpf_iter_num_destroy(&it); |
214 | |
215 | res_overfetched_elem_cnt = cnt; |
216 | |
217 | return 0; |
218 | } |
219 | |
220 | const volatile __s64 exp_fail_elem_cnt = 20 + 0; |
221 | __s64 res_fail_elem_cnt; |
222 | |
223 | SEC("raw_tp/sys_enter" ) |
224 | int num_fail_elem_cnt(const void *ctx) |
225 | { |
226 | struct bpf_iter_num it; |
227 | int cnt = 0, *v, i; |
228 | |
229 | bpf_iter_num_new(&it, 100, 10); |
230 | for (i = 0; i < 10; i++) { |
231 | v = bpf_iter_num_next(&it); |
232 | if (v) |
233 | cnt++; |
234 | } |
235 | bpf_iter_num_destroy(&it); |
236 | |
237 | res_fail_elem_cnt = 20 + cnt; |
238 | |
239 | return 0; |
240 | } |
241 | |
242 | char _license[] SEC("license" ) = "GPL" ; |
243 | |