1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
|
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2024 Yafang Shao <laoar.shao@gmail.com> */
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>
#include "bpf_misc.h"
#include "task_kfunc_common.h"
char _license[] SEC("license") = "GPL";
int bpf_iter_bits_new(struct bpf_iter_bits *it, const u64 *unsafe_ptr__ign,
u32 nr_bits) __ksym __weak;
int *bpf_iter_bits_next(struct bpf_iter_bits *it) __ksym __weak;
void bpf_iter_bits_destroy(struct bpf_iter_bits *it) __ksym __weak;
u64 bits_array[511] = {};
SEC("iter.s/cgroup")
__description("bits iter without destroy")
__failure __msg("Unreleased reference")
int BPF_PROG(no_destroy, struct bpf_iter_meta *meta, struct cgroup *cgrp)
{
struct bpf_iter_bits it;
u64 data = 1;
bpf_iter_bits_new(&it, &data, 1);
bpf_iter_bits_next(&it);
return 0;
}
SEC("iter/cgroup")
__description("uninitialized iter in ->next()")
__failure __msg("expected an initialized iter_bits as arg #1")
int BPF_PROG(next_uninit, struct bpf_iter_meta *meta, struct cgroup *cgrp)
{
struct bpf_iter_bits *it = NULL;
bpf_iter_bits_next(it);
return 0;
}
SEC("iter/cgroup")
__description("uninitialized iter in ->destroy()")
__failure __msg("expected an initialized iter_bits as arg #1")
int BPF_PROG(destroy_uninit, struct bpf_iter_meta *meta, struct cgroup *cgrp)
{
struct bpf_iter_bits it = {};
bpf_iter_bits_destroy(&it);
return 0;
}
SEC("syscall")
__description("null pointer")
__success __retval(0)
int null_pointer(void)
{
struct bpf_iter_bits iter;
int err, nr = 0;
int *bit;
err = bpf_iter_bits_new(&iter, NULL, 1);
bpf_iter_bits_destroy(&iter);
if (err != -EINVAL)
return 1;
bpf_for_each(bits, bit, NULL, 1)
nr++;
return nr;
}
SEC("syscall")
__description("bits copy")
__success __retval(10)
int bits_copy(void)
{
u64 data = 0xf7310UL; /* 4 + 3 + 2 + 1 + 0*/
int nr = 0;
int *bit;
bpf_for_each(bits, bit, &data, 1)
nr++;
return nr;
}
SEC("syscall")
__description("bits memalloc")
__success __retval(64)
int bits_memalloc(void)
{
u64 data[2];
int nr = 0;
int *bit;
__builtin_memset(&data, 0xf0, sizeof(data)); /* 4 * 16 */
bpf_for_each(bits, bit, &data[0], ARRAY_SIZE(data))
nr++;
return nr;
}
SEC("syscall")
__description("bit index")
__success __retval(8)
int bit_index(void)
{
u64 data = 0x100;
int bit_idx = 0;
int *bit;
bpf_for_each(bits, bit, &data, 1) {
if (*bit == 0)
continue;
bit_idx = *bit;
}
return bit_idx;
}
SEC("syscall")
__description("bits too big")
__success __retval(0)
int bits_too_big(void)
{
u64 data[4];
int nr = 0;
int *bit;
__builtin_memset(&data, 0xff, sizeof(data));
bpf_for_each(bits, bit, &data[0], 512) /* Be greater than 511 */
nr++;
return nr;
}
SEC("syscall")
__description("fewer words")
__success __retval(1)
int fewer_words(void)
{
u64 data[2] = {0x1, 0xff};
int nr = 0;
int *bit;
bpf_for_each(bits, bit, &data[0], 1)
nr++;
return nr;
}
SEC("syscall")
__description("zero words")
__success __retval(0)
int zero_words(void)
{
u64 data[2] = {0x1, 0xff};
int nr = 0;
int *bit;
bpf_for_each(bits, bit, &data[0], 0)
nr++;
return nr;
}
SEC("syscall")
__description("huge words")
__success __retval(0)
int huge_words(void)
{
u64 data[8] = {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1};
int nr = 0;
int *bit;
bpf_for_each(bits, bit, &data[0], 67108865)
nr++;
return nr;
}
SEC("syscall")
__description("max words")
__success __retval(4)
int max_words(void)
{
volatile int nr = 0;
int *bit;
bits_array[0] = (1ULL << 63) | 1U;
bits_array[510] = (1ULL << 33) | (1ULL << 32);
bpf_for_each(bits, bit, bits_array, 511) {
if (nr == 0 && *bit != 0)
break;
if (nr == 2 && *bit != 32672)
break;
nr++;
}
return nr;
}
SEC("syscall")
__description("bad words")
__success __retval(0)
int bad_words(void)
{
void *bad_addr = (void *)-4095;
struct bpf_iter_bits iter;
volatile int nr;
int *bit;
int err;
err = bpf_iter_bits_new(&iter, bad_addr, 1);
bpf_iter_bits_destroy(&iter);
if (err != -EFAULT)
return 1;
nr = 0;
bpf_for_each(bits, bit, bad_addr, 1)
nr++;
if (nr != 0)
return 2;
err = bpf_iter_bits_new(&iter, bad_addr, 4);
bpf_iter_bits_destroy(&iter);
if (err != -EFAULT)
return 3;
nr = 0;
bpf_for_each(bits, bit, bad_addr, 4)
nr++;
if (nr != 0)
return 4;
return 0;
}
|
