xref: /linux/tools/testing/selftests/bpf/progs/percpu_alloc_fail.c (revision 4f18de58a44cc15e2ec18c07bb1897d97f9dc1a8)
1 #include "bpf_experimental.h"
2 #include "bpf_misc.h"
3 
4 struct val_t {
5 	long b, c, d;
6 };
7 
8 struct val2_t {
9 	long b;
10 };
11 
12 struct val_with_ptr_t {
13 	char *p;
14 };
15 
16 struct val_with_rb_root_t {
17 	struct bpf_spin_lock lock;
18 };
19 
20 struct val_600b_t {
21 	char b[600];
22 };
23 
24 struct elem {
25 	long sum;
26 	struct val_t __percpu_kptr *pc;
27 	struct val_t __percpu_kptr *pc2;
28 };
29 
30 struct {
31 	__uint(type, BPF_MAP_TYPE_ARRAY);
32 	__uint(max_entries, 1);
33 	__type(key, int);
34 	__type(value, struct elem);
35 } array SEC(".maps");
36 
37 struct kernel_percpu_elem {
38 	struct task_struct __percpu_kptr *task;
39 };
40 
41 struct {
42 	__uint(type, BPF_MAP_TYPE_ARRAY);
43 	__uint(max_entries, 1);
44 	__type(key, int);
45 	__type(value, struct kernel_percpu_elem);
46 } kernel_percpu_array SEC(".maps");
47 
48 struct task_struct *bpf_task_from_pid(s32 pid) __ksym;
49 void bpf_task_release(struct task_struct *p) __ksym;
50 void bpf_rcu_read_lock(void) __ksym;
51 void bpf_rcu_read_unlock(void) __ksym;
52 
53 long ret;
54 
55 SEC("?fentry/bpf_fentry_test1")
56 __failure __msg("store to referenced kptr disallowed")
57 int BPF_PROG(test_array_map_1)
58 {
59 	struct val_t __percpu_kptr *p;
60 	struct elem *e;
61 	int index = 0;
62 
63 	e = bpf_map_lookup_elem(&array, &index);
64 	if (!e)
65 		return 0;
66 
67 	p = bpf_percpu_obj_new(struct val_t);
68 	if (!p)
69 		return 0;
70 
71 	p = bpf_kptr_xchg(&e->pc, p);
72 	if (p)
73 		bpf_percpu_obj_drop(p);
74 
75 	e->pc = (struct val_t __percpu_kptr *)ret;
76 	return 0;
77 }
78 
79 SEC("?fentry/bpf_fentry_test1")
80 __failure __msg("invalid kptr access, R2 type=percpu_ptr_val2_t expected=ptr_val_t")
81 int BPF_PROG(test_array_map_2)
82 {
83 	struct val2_t __percpu_kptr *p2;
84 	struct val_t __percpu_kptr *p;
85 	struct elem *e;
86 	int index = 0;
87 
88 	e = bpf_map_lookup_elem(&array, &index);
89 	if (!e)
90 		return 0;
91 
92 	p2 = bpf_percpu_obj_new(struct val2_t);
93 	if (!p2)
94 		return 0;
95 
96 	p = bpf_kptr_xchg(&e->pc, p2);
97 	if (p)
98 		bpf_percpu_obj_drop(p);
99 
100 	return 0;
101 }
102 
103 SEC("?fentry.s/bpf_fentry_test1")
104 __failure __msg("R1 type=scalar expected=percpu_ptr_, percpu_rcu_ptr_, percpu_trusted_ptr_")
105 int BPF_PROG(test_array_map_3)
106 {
107 	struct val_t __percpu_kptr *p, *p1;
108 	struct val_t *v;
109 	struct elem *e;
110 	int index = 0;
111 
112 	e = bpf_map_lookup_elem(&array, &index);
113 	if (!e)
114 		return 0;
115 
116 	p = bpf_percpu_obj_new(struct val_t);
117 	if (!p)
118 		return 0;
119 
120 	p1 = bpf_kptr_xchg(&e->pc, p);
121 	if (p1)
122 		bpf_percpu_obj_drop(p1);
123 
124 	v = bpf_this_cpu_ptr(p);
125 	ret = v->b;
126 	return 0;
127 }
128 
129 SEC("?fentry.s/bpf_fentry_test1")
130 __failure __msg("Possibly NULL pointer passed to trusted R1")
131 int BPF_PROG(reject_nullable_percpu_xchg_alias)
132 {
133 	struct val_t __percpu_kptr *p1, *p2, *old;
134 	struct val_t *v;
135 	struct elem *e;
136 	int index = 0;
137 
138 	e = bpf_map_lookup_elem(&array, &index);
139 	if (!e)
140 		return 0;
141 
142 	p1 = bpf_percpu_obj_new(struct val_t);
143 	p2 = bpf_percpu_obj_new(struct val_t);
144 
145 	bpf_rcu_read_lock();
146 	old = bpf_kptr_xchg(&e->pc, p1);
147 	if (old)
148 		bpf_percpu_obj_drop(old);
149 	old = bpf_kptr_xchg(&e->pc2, p2);
150 	if (old)
151 		bpf_percpu_obj_drop(old);
152 
153 	if (p1) {
154 		v = bpf_this_cpu_ptr(p2);
155 		v->b = 1;
156 	}
157 	bpf_rcu_read_unlock();
158 	return 0;
159 }
160 
161 SEC("?fentry.s/bpf_fentry_test1")
162 __failure __msg("R1 expected for bpf_percpu_obj_drop()")
163 int BPF_PROG(test_array_map_4)
164 {
165 	struct val_t __percpu_kptr *p;
166 
167 	p = bpf_percpu_obj_new(struct val_t);
168 	if (!p)
169 		return 0;
170 
171 	bpf_obj_drop(p);
172 	return 0;
173 }
174 
175 SEC("?fentry.s/bpf_fentry_test1")
176 __failure __msg("R1 expected for bpf_obj_drop()")
177 int BPF_PROG(test_array_map_5)
178 {
179 	struct val_t *p;
180 
181 	p = bpf_obj_new(struct val_t);
182 	if (!p)
183 		return 0;
184 
185 	bpf_percpu_obj_drop(p);
186 	return 0;
187 }
188 
189 SEC("?syscall")
190 __failure __msg("invalid kptr access, R2 type=trusted_ptr_ expected=ptr_task_struct")
191 int reject_kernel_ptr_into_percpu_kptr(void *ctx)
192 {
193 	struct kernel_percpu_elem *e;
194 	struct task_struct *p, *old;
195 	int index = 0;
196 
197 	e = bpf_map_lookup_elem(&kernel_percpu_array, &index);
198 	if (!e)
199 		return 0;
200 
201 	p = bpf_task_from_pid(1);
202 	if (!p)
203 		return 0;
204 
205 	old = bpf_kptr_xchg(&e->task, p);
206 	if (old)
207 		bpf_task_release(old);
208 	return 0;
209 }
210 
211 SEC("?fentry.s/bpf_fentry_test1")
212 __failure __msg("invalid kptr access, R2 type=ptr_ expected=ptr_val_t")
213 int BPF_PROG(reject_plain_alloc_into_percpu_kptr)
214 {
215 	struct val_t __percpu_kptr *old;
216 	struct val_t *p;
217 	struct elem *e;
218 	int index = 0;
219 
220 	e = bpf_map_lookup_elem(&array, &index);
221 	if (!e)
222 		return 0;
223 
224 	p = bpf_obj_new(struct val_t);
225 	if (!p)
226 		return 0;
227 
228 	old = bpf_kptr_xchg(&e->pc, p);
229 	if (old)
230 		bpf_percpu_obj_drop(old);
231 	return 0;
232 }
233 
234 SEC("?fentry.s/bpf_fentry_test1")
235 __failure __msg("bpf_percpu_obj_new type ID argument must be of a struct of scalars")
236 int BPF_PROG(test_array_map_6)
237 {
238 	struct val_with_ptr_t __percpu_kptr *p;
239 
240 	p = bpf_percpu_obj_new(struct val_with_ptr_t);
241 	if (!p)
242 		return 0;
243 
244 	bpf_percpu_obj_drop(p);
245 	return 0;
246 }
247 
248 SEC("?fentry.s/bpf_fentry_test1")
249 __failure __msg("bpf_percpu_obj_new type ID argument must not contain special fields")
250 int BPF_PROG(test_array_map_7)
251 {
252 	struct val_with_rb_root_t __percpu_kptr *p;
253 
254 	p = bpf_percpu_obj_new(struct val_with_rb_root_t);
255 	if (!p)
256 		return 0;
257 
258 	bpf_percpu_obj_drop(p);
259 	return 0;
260 }
261 
262 SEC("?fentry.s/bpf_fentry_test1")
263 __failure __msg("bpf_percpu_obj_new type size (600) is greater than 512")
264 int BPF_PROG(test_array_map_8)
265 {
266 	struct val_600b_t __percpu_kptr *p;
267 
268 	p = bpf_percpu_obj_new(struct val_600b_t);
269 	if (!p)
270 		return 0;
271 
272 	bpf_percpu_obj_drop(p);
273 	return 0;
274 }
275 
276 char _license[] SEC("license") = "GPL";
277