Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
3 : : */
4 : : #include <linux/bpf.h>
5 : : #include <linux/rcupdate.h>
6 : : #include <linux/random.h>
7 : : #include <linux/smp.h>
8 : : #include <linux/topology.h>
9 : : #include <linux/ktime.h>
10 : : #include <linux/sched.h>
11 : : #include <linux/uidgid.h>
12 : : #include <linux/filter.h>
13 : : #include <linux/ctype.h>
14 : :
15 : : #include "../../lib/kstrtox.h"
16 : :
17 : : /* If kernel subsystem is allowing eBPF programs to call this function,
18 : : * inside its own verifier_ops->get_func_proto() callback it should return
19 : : * bpf_map_lookup_elem_proto, so that verifier can properly check the arguments
20 : : *
21 : : * Different map implementations will rely on rcu in map methods
22 : : * lookup/update/delete, therefore eBPF programs must run under rcu lock
23 : : * if program is allowed to access maps, so check rcu_read_lock_held in
24 : : * all three functions.
25 : : */
26 : 0 : BPF_CALL_2(bpf_map_lookup_elem, struct bpf_map *, map, void *, key)
27 : : {
28 [ # # # # ]: 0 : WARN_ON_ONCE(!rcu_read_lock_held());
29 : 0 : return (unsigned long) map->ops->map_lookup_elem(map, key);
30 : : }
31 : :
32 : : const struct bpf_func_proto bpf_map_lookup_elem_proto = {
33 : : .func = bpf_map_lookup_elem,
34 : : .gpl_only = false,
35 : : .pkt_access = true,
36 : : .ret_type = RET_PTR_TO_MAP_VALUE_OR_NULL,
37 : : .arg1_type = ARG_CONST_MAP_PTR,
38 : : .arg2_type = ARG_PTR_TO_MAP_KEY,
39 : : };
40 : :
41 : 0 : BPF_CALL_4(bpf_map_update_elem, struct bpf_map *, map, void *, key,
42 : : void *, value, u64, flags)
43 : : {
44 [ # # # # ]: 0 : WARN_ON_ONCE(!rcu_read_lock_held());
45 : 0 : return map->ops->map_update_elem(map, key, value, flags);
46 : : }
47 : :
48 : : const struct bpf_func_proto bpf_map_update_elem_proto = {
49 : : .func = bpf_map_update_elem,
50 : : .gpl_only = false,
51 : : .pkt_access = true,
52 : : .ret_type = RET_INTEGER,
53 : : .arg1_type = ARG_CONST_MAP_PTR,
54 : : .arg2_type = ARG_PTR_TO_MAP_KEY,
55 : : .arg3_type = ARG_PTR_TO_MAP_VALUE,
56 : : .arg4_type = ARG_ANYTHING,
57 : : };
58 : :
59 : 0 : BPF_CALL_2(bpf_map_delete_elem, struct bpf_map *, map, void *, key)
60 : : {
61 [ # # # # ]: 0 : WARN_ON_ONCE(!rcu_read_lock_held());
62 : 0 : return map->ops->map_delete_elem(map, key);
63 : : }
64 : :
65 : : const struct bpf_func_proto bpf_map_delete_elem_proto = {
66 : : .func = bpf_map_delete_elem,
67 : : .gpl_only = false,
68 : : .pkt_access = true,
69 : : .ret_type = RET_INTEGER,
70 : : .arg1_type = ARG_CONST_MAP_PTR,
71 : : .arg2_type = ARG_PTR_TO_MAP_KEY,
72 : : };
73 : :
74 : 0 : BPF_CALL_3(bpf_map_push_elem, struct bpf_map *, map, void *, value, u64, flags)
75 : : {
76 : 0 : return map->ops->map_push_elem(map, value, flags);
77 : : }
78 : :
79 : : const struct bpf_func_proto bpf_map_push_elem_proto = {
80 : : .func = bpf_map_push_elem,
81 : : .gpl_only = false,
82 : : .pkt_access = true,
83 : : .ret_type = RET_INTEGER,
84 : : .arg1_type = ARG_CONST_MAP_PTR,
85 : : .arg2_type = ARG_PTR_TO_MAP_VALUE,
86 : : .arg3_type = ARG_ANYTHING,
87 : : };
88 : :
89 : 0 : BPF_CALL_2(bpf_map_pop_elem, struct bpf_map *, map, void *, value)
90 : : {
91 : 0 : return map->ops->map_pop_elem(map, value);
92 : : }
93 : :
94 : : const struct bpf_func_proto bpf_map_pop_elem_proto = {
95 : : .func = bpf_map_pop_elem,
96 : : .gpl_only = false,
97 : : .ret_type = RET_INTEGER,
98 : : .arg1_type = ARG_CONST_MAP_PTR,
99 : : .arg2_type = ARG_PTR_TO_UNINIT_MAP_VALUE,
100 : : };
101 : :
102 : 0 : BPF_CALL_2(bpf_map_peek_elem, struct bpf_map *, map, void *, value)
103 : : {
104 : 0 : return map->ops->map_peek_elem(map, value);
105 : : }
106 : :
107 : : const struct bpf_func_proto bpf_map_peek_elem_proto = {
108 : : .func = bpf_map_pop_elem,
109 : : .gpl_only = false,
110 : : .ret_type = RET_INTEGER,
111 : : .arg1_type = ARG_CONST_MAP_PTR,
112 : : .arg2_type = ARG_PTR_TO_UNINIT_MAP_VALUE,
113 : : };
114 : :
115 : : const struct bpf_func_proto bpf_get_prandom_u32_proto = {
116 : : .func = bpf_user_rnd_u32,
117 : : .gpl_only = false,
118 : : .ret_type = RET_INTEGER,
119 : : };
120 : :
121 : 0 : BPF_CALL_0(bpf_get_smp_processor_id)
122 : : {
123 : 0 : return smp_processor_id();
124 : : }
125 : :
126 : : const struct bpf_func_proto bpf_get_smp_processor_id_proto = {
127 : : .func = bpf_get_smp_processor_id,
128 : : .gpl_only = false,
129 : : .ret_type = RET_INTEGER,
130 : : };
131 : :
132 : 0 : BPF_CALL_0(bpf_get_numa_node_id)
133 : : {
134 : 0 : return numa_node_id();
135 : : }
136 : :
137 : : const struct bpf_func_proto bpf_get_numa_node_id_proto = {
138 : : .func = bpf_get_numa_node_id,
139 : : .gpl_only = false,
140 : : .ret_type = RET_INTEGER,
141 : : };
142 : :
143 : 0 : BPF_CALL_0(bpf_ktime_get_ns)
144 : : {
145 : : /* NMI safe access to clock monotonic */
146 : 0 : return ktime_get_mono_fast_ns();
147 : : }
148 : :
149 : : const struct bpf_func_proto bpf_ktime_get_ns_proto = {
150 : : .func = bpf_ktime_get_ns,
151 : : .gpl_only = true,
152 : : .ret_type = RET_INTEGER,
153 : : };
154 : :
155 : 0 : BPF_CALL_0(bpf_get_current_pid_tgid)
156 : : {
157 : 0 : struct task_struct *task = current;
158 : :
159 [ # # ]: 0 : if (unlikely(!task))
160 : : return -EINVAL;
161 : :
162 : 0 : return (u64) task->tgid << 32 | task->pid;
163 : : }
164 : :
165 : : const struct bpf_func_proto bpf_get_current_pid_tgid_proto = {
166 : : .func = bpf_get_current_pid_tgid,
167 : : .gpl_only = false,
168 : : .ret_type = RET_INTEGER,
169 : : };
170 : :
171 : 0 : BPF_CALL_0(bpf_get_current_uid_gid)
172 : : {
173 : 0 : struct task_struct *task = current;
174 : : kuid_t uid;
175 : : kgid_t gid;
176 : :
177 [ # # ]: 0 : if (unlikely(!task))
178 : : return -EINVAL;
179 : :
180 : 0 : current_uid_gid(&uid, &gid);
181 : 0 : return (u64) from_kgid(&init_user_ns, gid) << 32 |
182 : 0 : from_kuid(&init_user_ns, uid);
183 : : }
184 : :
185 : : const struct bpf_func_proto bpf_get_current_uid_gid_proto = {
186 : : .func = bpf_get_current_uid_gid,
187 : : .gpl_only = false,
188 : : .ret_type = RET_INTEGER,
189 : : };
190 : :
191 : 0 : BPF_CALL_2(bpf_get_current_comm, char *, buf, u32, size)
192 : : {
193 : 0 : struct task_struct *task = current;
194 : :
195 [ # # ]: 0 : if (unlikely(!task))
196 : : goto err_clear;
197 : :
198 : 0 : strncpy(buf, task->comm, size);
199 : :
200 : : /* Verifier guarantees that size > 0. For task->comm exceeding
201 : : * size, guarantee that buf is %NUL-terminated. Unconditionally
202 : : * done here to save the size test.
203 : : */
204 : 0 : buf[size - 1] = 0;
205 : : return 0;
206 : : err_clear:
207 : 0 : memset(buf, 0, size);
208 : : return -EINVAL;
209 : : }
210 : :
211 : : const struct bpf_func_proto bpf_get_current_comm_proto = {
212 : : .func = bpf_get_current_comm,
213 : : .gpl_only = false,
214 : : .ret_type = RET_INTEGER,
215 : : .arg1_type = ARG_PTR_TO_UNINIT_MEM,
216 : : .arg2_type = ARG_CONST_SIZE,
217 : : };
218 : :
219 : : #if defined(CONFIG_QUEUED_SPINLOCKS) || defined(CONFIG_BPF_ARCH_SPINLOCK)
220 : :
221 : : static inline void __bpf_spin_lock(struct bpf_spin_lock *lock)
222 : : {
223 : : arch_spinlock_t *l = (void *)lock;
224 : : union {
225 : : __u32 val;
226 : : arch_spinlock_t lock;
227 : : } u = { .lock = __ARCH_SPIN_LOCK_UNLOCKED };
228 : :
229 : : compiletime_assert(u.val == 0, "__ARCH_SPIN_LOCK_UNLOCKED not 0");
230 : : BUILD_BUG_ON(sizeof(*l) != sizeof(__u32));
231 : : BUILD_BUG_ON(sizeof(*lock) != sizeof(__u32));
232 : : arch_spin_lock(l);
233 : : }
234 : :
235 : : static inline void __bpf_spin_unlock(struct bpf_spin_lock *lock)
236 : : {
237 : : arch_spinlock_t *l = (void *)lock;
238 : :
239 : : arch_spin_unlock(l);
240 : : }
241 : :
242 : : #else
243 : :
244 : 0 : static inline void __bpf_spin_lock(struct bpf_spin_lock *lock)
245 : : {
246 : : atomic_t *l = (void *)lock;
247 : :
248 : : BUILD_BUG_ON(sizeof(*l) != sizeof(*lock));
249 : : do {
250 [ # # ]: 0 : atomic_cond_read_relaxed(l, !VAL);
251 [ # # ]: 0 : } while (atomic_xchg(l, 1));
252 : 0 : }
253 : :
254 : 0 : static inline void __bpf_spin_unlock(struct bpf_spin_lock *lock)
255 : : {
256 : : atomic_t *l = (void *)lock;
257 : :
258 : : atomic_set_release(l, 0);
259 : 0 : }
260 : :
261 : : #endif
262 : :
263 : : static DEFINE_PER_CPU(unsigned long, irqsave_flags);
264 : :
265 : 0 : notrace BPF_CALL_1(bpf_spin_lock, struct bpf_spin_lock *, lock)
266 : : {
267 : : unsigned long flags;
268 : :
269 : 0 : local_irq_save(flags);
270 : 0 : __bpf_spin_lock(lock);
271 : 0 : __this_cpu_write(irqsave_flags, flags);
272 : : return 0;
273 : : }
274 : :
275 : : const struct bpf_func_proto bpf_spin_lock_proto = {
276 : : .func = bpf_spin_lock,
277 : : .gpl_only = false,
278 : : .ret_type = RET_VOID,
279 : : .arg1_type = ARG_PTR_TO_SPIN_LOCK,
280 : : };
281 : :
282 : 0 : notrace BPF_CALL_1(bpf_spin_unlock, struct bpf_spin_lock *, lock)
283 : : {
284 : : unsigned long flags;
285 : :
286 : 0 : flags = __this_cpu_read(irqsave_flags);
287 : 0 : __bpf_spin_unlock(lock);
288 [ # # # # ]: 0 : local_irq_restore(flags);
289 : : return 0;
290 : : }
291 : :
292 : : const struct bpf_func_proto bpf_spin_unlock_proto = {
293 : : .func = bpf_spin_unlock,
294 : : .gpl_only = false,
295 : : .ret_type = RET_VOID,
296 : : .arg1_type = ARG_PTR_TO_SPIN_LOCK,
297 : : };
298 : :
299 : 0 : void copy_map_value_locked(struct bpf_map *map, void *dst, void *src,
300 : : bool lock_src)
301 : : {
302 : : struct bpf_spin_lock *lock;
303 : :
304 [ # # ]: 0 : if (lock_src)
305 : 0 : lock = src + map->spin_lock_off;
306 : : else
307 : 0 : lock = dst + map->spin_lock_off;
308 : 0 : preempt_disable();
309 : : ____bpf_spin_lock(lock);
310 : 0 : copy_map_value(map, dst, src);
311 : : ____bpf_spin_unlock(lock);
312 : 0 : preempt_enable();
313 : 0 : }
314 : :
315 : : #ifdef CONFIG_CGROUPS
316 : 0 : BPF_CALL_0(bpf_get_current_cgroup_id)
317 : : {
318 : 0 : struct cgroup *cgrp = task_dfl_cgroup(current);
319 : :
320 : 0 : return cgrp->kn->id.id;
321 : : }
322 : :
323 : : const struct bpf_func_proto bpf_get_current_cgroup_id_proto = {
324 : : .func = bpf_get_current_cgroup_id,
325 : : .gpl_only = false,
326 : : .ret_type = RET_INTEGER,
327 : : };
328 : :
329 : : #ifdef CONFIG_CGROUP_BPF
330 : : DECLARE_PER_CPU(struct bpf_cgroup_storage*,
331 : : bpf_cgroup_storage[MAX_BPF_CGROUP_STORAGE_TYPE]);
332 : :
333 : 0 : BPF_CALL_2(bpf_get_local_storage, struct bpf_map *, map, u64, flags)
334 : : {
335 : : /* flags argument is not used now,
336 : : * but provides an ability to extend the API.
337 : : * verifier checks that its value is correct.
338 : : */
339 : 0 : enum bpf_cgroup_storage_type stype = cgroup_storage_type(map);
340 : : struct bpf_cgroup_storage *storage;
341 : : void *ptr;
342 : :
343 : 0 : storage = this_cpu_read(bpf_cgroup_storage[stype]);
344 : :
345 [ # # ]: 0 : if (stype == BPF_CGROUP_STORAGE_SHARED)
346 : 0 : ptr = &READ_ONCE(storage->buf)->data[0];
347 : : else
348 : 0 : ptr = this_cpu_ptr(storage->percpu_buf);
349 : :
350 : 0 : return (unsigned long)ptr;
351 : : }
352 : :
353 : : const struct bpf_func_proto bpf_get_local_storage_proto = {
354 : : .func = bpf_get_local_storage,
355 : : .gpl_only = false,
356 : : .ret_type = RET_PTR_TO_MAP_VALUE,
357 : : .arg1_type = ARG_CONST_MAP_PTR,
358 : : .arg2_type = ARG_ANYTHING,
359 : : };
360 : : #endif
361 : :
362 : : #define BPF_STRTOX_BASE_MASK 0x1F
363 : :
364 : 0 : static int __bpf_strtoull(const char *buf, size_t buf_len, u64 flags,
365 : : unsigned long long *res, bool *is_negative)
366 : : {
367 : 0 : unsigned int base = flags & BPF_STRTOX_BASE_MASK;
368 : : const char *cur_buf = buf;
369 : : size_t cur_len = buf_len;
370 : : unsigned int consumed;
371 : : size_t val_len;
372 : : char str[64];
373 : :
374 [ # # # # ]: 0 : if (!buf || !buf_len || !res || !is_negative)
375 : : return -EINVAL;
376 : :
377 [ # # # # ]: 0 : if (base != 0 && base != 8 && base != 10 && base != 16)
378 : : return -EINVAL;
379 : :
380 [ # # ]: 0 : if (flags & ~BPF_STRTOX_BASE_MASK)
381 : : return -EINVAL;
382 : :
383 [ # # # # ]: 0 : while (cur_buf < buf + buf_len && isspace(*cur_buf))
384 : 0 : ++cur_buf;
385 : :
386 [ # # # # ]: 0 : *is_negative = (cur_buf < buf + buf_len && *cur_buf == '-');
387 [ # # ]: 0 : if (*is_negative)
388 : 0 : ++cur_buf;
389 : :
390 : 0 : consumed = cur_buf - buf;
391 : 0 : cur_len -= consumed;
392 [ # # ]: 0 : if (!cur_len)
393 : : return -EINVAL;
394 : :
395 : 0 : cur_len = min(cur_len, sizeof(str) - 1);
396 : 0 : memcpy(str, cur_buf, cur_len);
397 : 0 : str[cur_len] = '\0';
398 : : cur_buf = str;
399 : :
400 : 0 : cur_buf = _parse_integer_fixup_radix(cur_buf, &base);
401 : 0 : val_len = _parse_integer(cur_buf, base, res);
402 : :
403 [ # # ]: 0 : if (val_len & KSTRTOX_OVERFLOW)
404 : : return -ERANGE;
405 : :
406 [ # # ]: 0 : if (val_len == 0)
407 : : return -EINVAL;
408 : :
409 : 0 : cur_buf += val_len;
410 : 0 : consumed += cur_buf - str;
411 : :
412 : 0 : return consumed;
413 : : }
414 : :
415 : 0 : static int __bpf_strtoll(const char *buf, size_t buf_len, u64 flags,
416 : : long long *res)
417 : : {
418 : : unsigned long long _res;
419 : : bool is_negative;
420 : : int err;
421 : :
422 : 0 : err = __bpf_strtoull(buf, buf_len, flags, &_res, &is_negative);
423 [ # # ]: 0 : if (err < 0)
424 : : return err;
425 [ # # ]: 0 : if (is_negative) {
426 [ # # ]: 0 : if ((long long)-_res > 0)
427 : : return -ERANGE;
428 : 0 : *res = -_res;
429 : : } else {
430 [ # # ]: 0 : if ((long long)_res < 0)
431 : : return -ERANGE;
432 : 0 : *res = _res;
433 : : }
434 : 0 : return err;
435 : : }
436 : :
437 : 0 : BPF_CALL_4(bpf_strtol, const char *, buf, size_t, buf_len, u64, flags,
438 : : long *, res)
439 : : {
440 : : long long _res;
441 : : int err;
442 : :
443 : 0 : err = __bpf_strtoll(buf, buf_len, flags, &_res);
444 [ # # ]: 0 : if (err < 0)
445 : 0 : return err;
446 [ # # ]: 0 : if (_res != (long)_res)
447 : : return -ERANGE;
448 : 0 : *res = _res;
449 : 0 : return err;
450 : : }
451 : :
452 : : const struct bpf_func_proto bpf_strtol_proto = {
453 : : .func = bpf_strtol,
454 : : .gpl_only = false,
455 : : .ret_type = RET_INTEGER,
456 : : .arg1_type = ARG_PTR_TO_MEM,
457 : : .arg2_type = ARG_CONST_SIZE,
458 : : .arg3_type = ARG_ANYTHING,
459 : : .arg4_type = ARG_PTR_TO_LONG,
460 : : };
461 : :
462 : 0 : BPF_CALL_4(bpf_strtoul, const char *, buf, size_t, buf_len, u64, flags,
463 : : unsigned long *, res)
464 : : {
465 : : unsigned long long _res;
466 : : bool is_negative;
467 : : int err;
468 : :
469 : 0 : err = __bpf_strtoull(buf, buf_len, flags, &_res, &is_negative);
470 [ # # ]: 0 : if (err < 0)
471 : 0 : return err;
472 [ # # ]: 0 : if (is_negative)
473 : : return -EINVAL;
474 [ # # ]: 0 : if (_res != (unsigned long)_res)
475 : : return -ERANGE;
476 : 0 : *res = _res;
477 : 0 : return err;
478 : : }
479 : :
480 : : const struct bpf_func_proto bpf_strtoul_proto = {
481 : : .func = bpf_strtoul,
482 : : .gpl_only = false,
483 : : .ret_type = RET_INTEGER,
484 : : .arg1_type = ARG_PTR_TO_MEM,
485 : : .arg2_type = ARG_CONST_SIZE,
486 : : .arg3_type = ARG_ANYTHING,
487 : : .arg4_type = ARG_PTR_TO_LONG,
488 : : };
489 : : #endif
|
