~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/bpf/helpers.c

Version: ~ [ linux-5.16-rc3 ] ~ [ linux-5.15.5 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.82 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.162 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.218 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.256 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.291 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.293 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 #include <linux/jiffies.h>
 15 #include <linux/pid_namespace.h>
 16 #include <linux/proc_ns.h>
 17 #include <linux/security.h>
 18 
 19 #include "../../lib/kstrtox.h"
 20 
 21 /* If kernel subsystem is allowing eBPF programs to call this function,
 22  * inside its own verifier_ops->get_func_proto() callback it should return
 23  * bpf_map_lookup_elem_proto, so that verifier can properly check the arguments
 24  *
 25  * Different map implementations will rely on rcu in map methods
 26  * lookup/update/delete, therefore eBPF programs must run under rcu lock
 27  * if program is allowed to access maps, so check rcu_read_lock_held in
 28  * all three functions.
 29  */
 30 BPF_CALL_2(bpf_map_lookup_elem, struct bpf_map *, map, void *, key)
 31 {
 32         WARN_ON_ONCE(!rcu_read_lock_held());
 33         return (unsigned long) map->ops->map_lookup_elem(map, key);
 34 }
 35 
 36 const struct bpf_func_proto bpf_map_lookup_elem_proto = {
 37         .func           = bpf_map_lookup_elem,
 38         .gpl_only       = false,
 39         .pkt_access     = true,
 40         .ret_type       = RET_PTR_TO_MAP_VALUE_OR_NULL,
 41         .arg1_type      = ARG_CONST_MAP_PTR,
 42         .arg2_type      = ARG_PTR_TO_MAP_KEY,
 43 };
 44 
 45 BPF_CALL_4(bpf_map_update_elem, struct bpf_map *, map, void *, key,
 46            void *, value, u64, flags)
 47 {
 48         WARN_ON_ONCE(!rcu_read_lock_held());
 49         return map->ops->map_update_elem(map, key, value, flags);
 50 }
 51 
 52 const struct bpf_func_proto bpf_map_update_elem_proto = {
 53         .func           = bpf_map_update_elem,
 54         .gpl_only       = false,
 55         .pkt_access     = true,
 56         .ret_type       = RET_INTEGER,
 57         .arg1_type      = ARG_CONST_MAP_PTR,
 58         .arg2_type      = ARG_PTR_TO_MAP_KEY,
 59         .arg3_type      = ARG_PTR_TO_MAP_VALUE,
 60         .arg4_type      = ARG_ANYTHING,
 61 };
 62 
 63 BPF_CALL_2(bpf_map_delete_elem, struct bpf_map *, map, void *, key)
 64 {
 65         WARN_ON_ONCE(!rcu_read_lock_held());
 66         return map->ops->map_delete_elem(map, key);
 67 }
 68 
 69 const struct bpf_func_proto bpf_map_delete_elem_proto = {
 70         .func           = bpf_map_delete_elem,
 71         .gpl_only       = false,
 72         .pkt_access     = true,
 73         .ret_type       = RET_INTEGER,
 74         .arg1_type      = ARG_CONST_MAP_PTR,
 75         .arg2_type      = ARG_PTR_TO_MAP_KEY,
 76 };
 77 
 78 BPF_CALL_3(bpf_map_push_elem, struct bpf_map *, map, void *, value, u64, flags)
 79 {
 80         return map->ops->map_push_elem(map, value, flags);
 81 }
 82 
 83 const struct bpf_func_proto bpf_map_push_elem_proto = {
 84         .func           = bpf_map_push_elem,
 85         .gpl_only       = false,
 86         .pkt_access     = true,
 87         .ret_type       = RET_INTEGER,
 88         .arg1_type      = ARG_CONST_MAP_PTR,
 89         .arg2_type      = ARG_PTR_TO_MAP_VALUE,
 90         .arg3_type      = ARG_ANYTHING,
 91 };
 92 
 93 BPF_CALL_2(bpf_map_pop_elem, struct bpf_map *, map, void *, value)
 94 {
 95         return map->ops->map_pop_elem(map, value);
 96 }
 97 
 98 const struct bpf_func_proto bpf_map_pop_elem_proto = {
 99         .func           = bpf_map_pop_elem,
100         .gpl_only       = false,
101         .ret_type       = RET_INTEGER,
102         .arg1_type      = ARG_CONST_MAP_PTR,
103         .arg2_type      = ARG_PTR_TO_UNINIT_MAP_VALUE,
104 };
105 
106 BPF_CALL_2(bpf_map_peek_elem, struct bpf_map *, map, void *, value)
107 {
108         return map->ops->map_peek_elem(map, value);
109 }
110 
111 const struct bpf_func_proto bpf_map_peek_elem_proto = {
112         .func           = bpf_map_peek_elem,
113         .gpl_only       = false,
114         .ret_type       = RET_INTEGER,
115         .arg1_type      = ARG_CONST_MAP_PTR,
116         .arg2_type      = ARG_PTR_TO_UNINIT_MAP_VALUE,
117 };
118 
119 const struct bpf_func_proto bpf_get_prandom_u32_proto = {
120         .func           = bpf_user_rnd_u32,
121         .gpl_only       = false,
122         .ret_type       = RET_INTEGER,
123 };
124 
125 BPF_CALL_0(bpf_get_smp_processor_id)
126 {
127         return smp_processor_id();
128 }
129 
130 const struct bpf_func_proto bpf_get_smp_processor_id_proto = {
131         .func           = bpf_get_smp_processor_id,
132         .gpl_only       = false,
133         .ret_type       = RET_INTEGER,
134 };
135 
136 BPF_CALL_0(bpf_get_numa_node_id)
137 {
138         return numa_node_id();
139 }
140 
141 const struct bpf_func_proto bpf_get_numa_node_id_proto = {
142         .func           = bpf_get_numa_node_id,
143         .gpl_only       = false,
144         .ret_type       = RET_INTEGER,
145 };
146 
147 BPF_CALL_0(bpf_ktime_get_ns)
148 {
149         /* NMI safe access to clock monotonic */
150         return ktime_get_mono_fast_ns();
151 }
152 
153 const struct bpf_func_proto bpf_ktime_get_ns_proto = {
154         .func           = bpf_ktime_get_ns,
155         .gpl_only       = false,
156         .ret_type       = RET_INTEGER,
157 };
158 
159 BPF_CALL_0(bpf_ktime_get_boot_ns)
160 {
161         /* NMI safe access to clock boottime */
162         return ktime_get_boot_fast_ns();
163 }
164 
165 const struct bpf_func_proto bpf_ktime_get_boot_ns_proto = {
166         .func           = bpf_ktime_get_boot_ns,
167         .gpl_only       = false,
168         .ret_type       = RET_INTEGER,
169 };
170 
171 BPF_CALL_0(bpf_ktime_get_coarse_ns)
172 {
173         return ktime_get_coarse_ns();
174 }
175 
176 const struct bpf_func_proto bpf_ktime_get_coarse_ns_proto = {
177         .func           = bpf_ktime_get_coarse_ns,
178         .gpl_only       = false,
179         .ret_type       = RET_INTEGER,
180 };
181 
182 BPF_CALL_0(bpf_get_current_pid_tgid)
183 {
184         struct task_struct *task = current;
185 
186         if (unlikely(!task))
187                 return -EINVAL;
188 
189         return (u64) task->tgid << 32 | task->pid;
190 }
191 
192 const struct bpf_func_proto bpf_get_current_pid_tgid_proto = {
193         .func           = bpf_get_current_pid_tgid,
194         .gpl_only       = false,
195         .ret_type       = RET_INTEGER,
196 };
197 
198 BPF_CALL_0(bpf_get_current_uid_gid)
199 {
200         struct task_struct *task = current;
201         kuid_t uid;
202         kgid_t gid;
203 
204         if (unlikely(!task))
205                 return -EINVAL;
206 
207         current_uid_gid(&uid, &gid);
208         return (u64) from_kgid(&init_user_ns, gid) << 32 |
209                      from_kuid(&init_user_ns, uid);
210 }
211 
212 const struct bpf_func_proto bpf_get_current_uid_gid_proto = {
213         .func           = bpf_get_current_uid_gid,
214         .gpl_only       = false,
215         .ret_type       = RET_INTEGER,
216 };
217 
218 BPF_CALL_2(bpf_get_current_comm, char *, buf, u32, size)
219 {
220         struct task_struct *task = current;
221 
222         if (unlikely(!task))
223                 goto err_clear;
224 
225         strncpy(buf, task->comm, size);
226 
227         /* Verifier guarantees that size > 0. For task->comm exceeding
228          * size, guarantee that buf is %NUL-terminated. Unconditionally
229          * done here to save the size test.
230          */
231         buf[size - 1] = 0;
232         return 0;
233 err_clear:
234         memset(buf, 0, size);
235         return -EINVAL;
236 }
237 
238 const struct bpf_func_proto bpf_get_current_comm_proto = {
239         .func           = bpf_get_current_comm,
240         .gpl_only       = false,
241         .ret_type       = RET_INTEGER,
242         .arg1_type      = ARG_PTR_TO_UNINIT_MEM,
243         .arg2_type      = ARG_CONST_SIZE,
244 };
245 
246 #if defined(CONFIG_QUEUED_SPINLOCKS) || defined(CONFIG_BPF_ARCH_SPINLOCK)
247 
248 static inline void __bpf_spin_lock(struct bpf_spin_lock *lock)
249 {
250         arch_spinlock_t *l = (void *)lock;
251         union {
252                 __u32 val;
253                 arch_spinlock_t lock;
254         } u = { .lock = __ARCH_SPIN_LOCK_UNLOCKED };
255 
256         compiletime_assert(u.val == 0, "__ARCH_SPIN_LOCK_UNLOCKED not 0");
257         BUILD_BUG_ON(sizeof(*l) != sizeof(__u32));
258         BUILD_BUG_ON(sizeof(*lock) != sizeof(__u32));
259         arch_spin_lock(l);
260 }
261 
262 static inline void __bpf_spin_unlock(struct bpf_spin_lock *lock)
263 {
264         arch_spinlock_t *l = (void *)lock;
265 
266         arch_spin_unlock(l);
267 }
268 
269 #else
270 
271 static inline void __bpf_spin_lock(struct bpf_spin_lock *lock)
272 {
273         atomic_t *l = (void *)lock;
274 
275         BUILD_BUG_ON(sizeof(*l) != sizeof(*lock));
276         do {
277                 atomic_cond_read_relaxed(l, !VAL);
278         } while (atomic_xchg(l, 1));
279 }
280 
281 static inline void __bpf_spin_unlock(struct bpf_spin_lock *lock)
282 {
283         atomic_t *l = (void *)lock;
284 
285         atomic_set_release(l, 0);
286 }
287 
288 #endif
289 
290 static DEFINE_PER_CPU(unsigned long, irqsave_flags);
291 
292 notrace BPF_CALL_1(bpf_spin_lock, struct bpf_spin_lock *, lock)
293 {
294         unsigned long flags;
295 
296         local_irq_save(flags);
297         __bpf_spin_lock(lock);
298         __this_cpu_write(irqsave_flags, flags);
299         return 0;
300 }
301 
302 const struct bpf_func_proto bpf_spin_lock_proto = {
303         .func           = bpf_spin_lock,
304         .gpl_only       = false,
305         .ret_type       = RET_VOID,
306         .arg1_type      = ARG_PTR_TO_SPIN_LOCK,
307 };
308 
309 notrace BPF_CALL_1(bpf_spin_unlock, struct bpf_spin_lock *, lock)
310 {
311         unsigned long flags;
312 
313         flags = __this_cpu_read(irqsave_flags);
314         __bpf_spin_unlock(lock);
315         local_irq_restore(flags);
316         return 0;
317 }
318 
319 const struct bpf_func_proto bpf_spin_unlock_proto = {
320         .func           = bpf_spin_unlock,
321         .gpl_only       = false,
322         .ret_type       = RET_VOID,
323         .arg1_type      = ARG_PTR_TO_SPIN_LOCK,
324 };
325 
326 void copy_map_value_locked(struct bpf_map *map, void *dst, void *src,
327                            bool lock_src)
328 {
329         struct bpf_spin_lock *lock;
330 
331         if (lock_src)
332                 lock = src + map->spin_lock_off;
333         else
334                 lock = dst + map->spin_lock_off;
335         preempt_disable();
336         ____bpf_spin_lock(lock);
337         copy_map_value(map, dst, src);
338         ____bpf_spin_unlock(lock);
339         preempt_enable();
340 }
341 
342 BPF_CALL_0(bpf_jiffies64)
343 {
344         return get_jiffies_64();
345 }
346 
347 const struct bpf_func_proto bpf_jiffies64_proto = {
348         .func           = bpf_jiffies64,
349         .gpl_only       = false,
350         .ret_type       = RET_INTEGER,
351 };
352 
353 #ifdef CONFIG_CGROUPS
354 BPF_CALL_0(bpf_get_current_cgroup_id)
355 {
356         struct cgroup *cgrp = task_dfl_cgroup(current);
357 
358         return cgroup_id(cgrp);
359 }
360 
361 const struct bpf_func_proto bpf_get_current_cgroup_id_proto = {
362         .func           = bpf_get_current_cgroup_id,
363         .gpl_only       = false,
364         .ret_type       = RET_INTEGER,
365 };
366 
367 BPF_CALL_1(bpf_get_current_ancestor_cgroup_id, int, ancestor_level)
368 {
369         struct cgroup *cgrp = task_dfl_cgroup(current);
370         struct cgroup *ancestor;
371 
372         ancestor = cgroup_ancestor(cgrp, ancestor_level);
373         if (!ancestor)
374                 return 0;
375         return cgroup_id(ancestor);
376 }
377 
378 const struct bpf_func_proto bpf_get_current_ancestor_cgroup_id_proto = {
379         .func           = bpf_get_current_ancestor_cgroup_id,
380         .gpl_only       = false,
381         .ret_type       = RET_INTEGER,
382         .arg1_type      = ARG_ANYTHING,
383 };
384 
385 #ifdef CONFIG_CGROUP_BPF
386 DECLARE_PER_CPU(struct bpf_cgroup_storage*,
387                 bpf_cgroup_storage[MAX_BPF_CGROUP_STORAGE_TYPE]);
388 
389 BPF_CALL_2(bpf_get_local_storage, struct bpf_map *, map, u64, flags)
390 {
391         /* flags argument is not used now,
392          * but provides an ability to extend the API.
393          * verifier checks that its value is correct.
394          */
395         enum bpf_cgroup_storage_type stype = cgroup_storage_type(map);
396         struct bpf_cgroup_storage *storage;
397         void *ptr;
398 
399         storage = this_cpu_read(bpf_cgroup_storage[stype]);
400 
401         if (stype == BPF_CGROUP_STORAGE_SHARED)
402                 ptr = &READ_ONCE(storage->buf)->data[0];
403         else
404                 ptr = this_cpu_ptr(storage->percpu_buf);
405 
406         return (unsigned long)ptr;
407 }
408 
409 const struct bpf_func_proto bpf_get_local_storage_proto = {
410         .func           = bpf_get_local_storage,
411         .gpl_only       = false,
412         .ret_type       = RET_PTR_TO_MAP_VALUE,
413         .arg1_type      = ARG_CONST_MAP_PTR,
414         .arg2_type      = ARG_ANYTHING,
415 };
416 #endif
417 
418 #define BPF_STRTOX_BASE_MASK 0x1F
419 
420 static int __bpf_strtoull(const char *buf, size_t buf_len, u64 flags,
421                           unsigned long long *res, bool *is_negative)
422 {
423         unsigned int base = flags & BPF_STRTOX_BASE_MASK;
424         const char *cur_buf = buf;
425         size_t cur_len = buf_len;
426         unsigned int consumed;
427         size_t val_len;
428         char str[64];
429 
430         if (!buf || !buf_len || !res || !is_negative)
431                 return -EINVAL;
432 
433         if (base != 0 && base != 8 && base != 10 && base != 16)
434                 return -EINVAL;
435 
436         if (flags & ~BPF_STRTOX_BASE_MASK)
437                 return -EINVAL;
438 
439         while (cur_buf < buf + buf_len && isspace(*cur_buf))
440                 ++cur_buf;
441 
442         *is_negative = (cur_buf < buf + buf_len && *cur_buf == '-');
443         if (*is_negative)
444                 ++cur_buf;
445 
446         consumed = cur_buf - buf;
447         cur_len -= consumed;
448         if (!cur_len)
449                 return -EINVAL;
450 
451         cur_len = min(cur_len, sizeof(str) - 1);
452         memcpy(str, cur_buf, cur_len);
453         str[cur_len] = '\0';
454         cur_buf = str;
455 
456         cur_buf = _parse_integer_fixup_radix(cur_buf, &base);
457         val_len = _parse_integer(cur_buf, base, res);
458 
459         if (val_len & KSTRTOX_OVERFLOW)
460                 return -ERANGE;
461 
462         if (val_len == 0)
463                 return -EINVAL;
464 
465         cur_buf += val_len;
466         consumed += cur_buf - str;
467 
468         return consumed;
469 }
470 
471 static int __bpf_strtoll(const char *buf, size_t buf_len, u64 flags,
472                          long long *res)
473 {
474         unsigned long long _res;
475         bool is_negative;
476         int err;
477 
478         err = __bpf_strtoull(buf, buf_len, flags, &_res, &is_negative);
479         if (err < 0)
480                 return err;
481         if (is_negative) {
482                 if ((long long)-_res > 0)
483                         return -ERANGE;
484                 *res = -_res;
485         } else {
486                 if ((long long)_res < 0)
487                         return -ERANGE;
488                 *res = _res;
489         }
490         return err;
491 }
492 
493 BPF_CALL_4(bpf_strtol, const char *, buf, size_t, buf_len, u64, flags,
494            long *, res)
495 {
496         long long _res;
497         int err;
498 
499         err = __bpf_strtoll(buf, buf_len, flags, &_res);
500         if (err < 0)
501                 return err;
502         if (_res != (long)_res)
503                 return -ERANGE;
504         *res = _res;
505         return err;
506 }
507 
508 const struct bpf_func_proto bpf_strtol_proto = {
509         .func           = bpf_strtol,
510         .gpl_only       = false,
511         .ret_type       = RET_INTEGER,
512         .arg1_type      = ARG_PTR_TO_MEM,
513         .arg2_type      = ARG_CONST_SIZE,
514         .arg3_type      = ARG_ANYTHING,
515         .arg4_type      = ARG_PTR_TO_LONG,
516 };
517 
518 BPF_CALL_4(bpf_strtoul, const char *, buf, size_t, buf_len, u64, flags,
519            unsigned long *, res)
520 {
521         unsigned long long _res;
522         bool is_negative;
523         int err;
524 
525         err = __bpf_strtoull(buf, buf_len, flags, &_res, &is_negative);
526         if (err < 0)
527                 return err;
528         if (is_negative)
529                 return -EINVAL;
530         if (_res != (unsigned long)_res)
531                 return -ERANGE;
532         *res = _res;
533         return err;
534 }
535 
536 const struct bpf_func_proto bpf_strtoul_proto = {
537         .func           = bpf_strtoul,
538         .gpl_only       = false,
539         .ret_type       = RET_INTEGER,
540         .arg1_type      = ARG_PTR_TO_MEM,
541         .arg2_type      = ARG_CONST_SIZE,
542         .arg3_type      = ARG_ANYTHING,
543         .arg4_type      = ARG_PTR_TO_LONG,
544 };
545 #endif
546 
547 BPF_CALL_4(bpf_get_ns_current_pid_tgid, u64, dev, u64, ino,
548            struct bpf_pidns_info *, nsdata, u32, size)
549 {
550         struct task_struct *task = current;
551         struct pid_namespace *pidns;
552         int err = -EINVAL;
553 
554         if (unlikely(size != sizeof(struct bpf_pidns_info)))
555                 goto clear;
556 
557         if (unlikely((u64)(dev_t)dev != dev))
558                 goto clear;
559 
560         if (unlikely(!task))
561                 goto clear;
562 
563         pidns = task_active_pid_ns(task);
564         if (unlikely(!pidns)) {
565                 err = -ENOENT;
566                 goto clear;
567         }
568 
569         if (!ns_match(&pidns->ns, (dev_t)dev, ino))
570                 goto clear;
571 
572         nsdata->pid = task_pid_nr_ns(task, pidns);
573         nsdata->tgid = task_tgid_nr_ns(task, pidns);
574         return 0;
575 clear:
576         memset((void *)nsdata, 0, (size_t) size);
577         return err;
578 }
579 
580 const struct bpf_func_proto bpf_get_ns_current_pid_tgid_proto = {
581         .func           = bpf_get_ns_current_pid_tgid,
582         .gpl_only       = false,
583         .ret_type       = RET_INTEGER,
584         .arg1_type      = ARG_ANYTHING,
585         .arg2_type      = ARG_ANYTHING,
586         .arg3_type      = ARG_PTR_TO_UNINIT_MEM,
587         .arg4_type      = ARG_CONST_SIZE,
588 };
589 
590 static const struct bpf_func_proto bpf_get_raw_smp_processor_id_proto = {
591         .func           = bpf_get_raw_cpu_id,
592         .gpl_only       = false,
593         .ret_type       = RET_INTEGER,
594 };
595 
596 BPF_CALL_5(bpf_event_output_data, void *, ctx, struct bpf_map *, map,
597            u64, flags, void *, data, u64, size)
598 {
599         if (unlikely(flags & ~(BPF_F_INDEX_MASK)))
600                 return -EINVAL;
601 
602         return bpf_event_output(map, flags, data, size, NULL, 0, NULL);
603 }
604 
605 const struct bpf_func_proto bpf_event_output_data_proto =  {
606         .func           = bpf_event_output_data,
607         .gpl_only       = true,
608         .ret_type       = RET_INTEGER,
609         .arg1_type      = ARG_PTR_TO_CTX,
610         .arg2_type      = ARG_CONST_MAP_PTR,
611         .arg3_type      = ARG_ANYTHING,
612         .arg4_type      = ARG_PTR_TO_MEM,
613         .arg5_type      = ARG_CONST_SIZE_OR_ZERO,
614 };
615 
616 BPF_CALL_3(bpf_copy_from_user, void *, dst, u32, size,
617            const void __user *, user_ptr)
618 {
619         int ret = copy_from_user(dst, user_ptr, size);
620 
621         if (unlikely(ret)) {
622                 memset(dst, 0, size);
623                 ret = -EFAULT;
624         }
625 
626         return ret;
627 }
628 
629 const struct bpf_func_proto bpf_copy_from_user_proto = {
630         .func           = bpf_copy_from_user,
631         .gpl_only       = false,
632         .ret_type       = RET_INTEGER,
633         .arg1_type      = ARG_PTR_TO_UNINIT_MEM,
634         .arg2_type      = ARG_CONST_SIZE_OR_ZERO,
635         .arg3_type      = ARG_ANYTHING,
636 };
637 
638 BPF_CALL_2(bpf_per_cpu_ptr, const void *, ptr, u32, cpu)
639 {
640         if (cpu >= nr_cpu_ids)
641                 return (unsigned long)NULL;
642 
643         return (unsigned long)per_cpu_ptr((const void __percpu *)ptr, cpu);
644 }
645 
646 const struct bpf_func_proto bpf_per_cpu_ptr_proto = {
647         .func           = bpf_per_cpu_ptr,
648         .gpl_only       = false,
649         .ret_type       = RET_PTR_TO_MEM_OR_BTF_ID_OR_NULL,
650         .arg1_type      = ARG_PTR_TO_PERCPU_BTF_ID,
651         .arg2_type      = ARG_ANYTHING,
652 };
653 
654 BPF_CALL_1(bpf_this_cpu_ptr, const void *, percpu_ptr)
655 {
656         return (unsigned long)this_cpu_ptr((const void __percpu *)percpu_ptr);
657 }
658 
659 const struct bpf_func_proto bpf_this_cpu_ptr_proto = {
660         .func           = bpf_this_cpu_ptr,
661         .gpl_only       = false,
662         .ret_type       = RET_PTR_TO_MEM_OR_BTF_ID,
663         .arg1_type      = ARG_PTR_TO_PERCPU_BTF_ID,
664 };
665 
666 const struct bpf_func_proto bpf_get_current_task_proto __weak;
667 const struct bpf_func_proto bpf_probe_read_user_proto __weak;
668 const struct bpf_func_proto bpf_probe_read_user_str_proto __weak;
669 const struct bpf_func_proto bpf_probe_read_kernel_proto __weak;
670 const struct bpf_func_proto bpf_probe_read_kernel_str_proto __weak;
671 
672 const struct bpf_func_proto *
673 bpf_base_func_proto(enum bpf_func_id func_id)
674 {
675         switch (func_id) {
676         case BPF_FUNC_map_lookup_elem:
677                 return &bpf_map_lookup_elem_proto;
678         case BPF_FUNC_map_update_elem:
679                 return &bpf_map_update_elem_proto;
680         case BPF_FUNC_map_delete_elem:
681                 return &bpf_map_delete_elem_proto;
682         case BPF_FUNC_map_push_elem:
683                 return &bpf_map_push_elem_proto;
684         case BPF_FUNC_map_pop_elem:
685                 return &bpf_map_pop_elem_proto;
686         case BPF_FUNC_map_peek_elem:
687                 return &bpf_map_peek_elem_proto;
688         case BPF_FUNC_get_prandom_u32:
689                 return &bpf_get_prandom_u32_proto;
690         case BPF_FUNC_get_smp_processor_id:
691                 return &bpf_get_raw_smp_processor_id_proto;
692         case BPF_FUNC_get_numa_node_id:
693                 return &bpf_get_numa_node_id_proto;
694         case BPF_FUNC_tail_call:
695                 return &bpf_tail_call_proto;
696         case BPF_FUNC_ktime_get_ns:
697                 return &bpf_ktime_get_ns_proto;
698         case BPF_FUNC_ktime_get_boot_ns:
699                 return &bpf_ktime_get_boot_ns_proto;
700         case BPF_FUNC_ktime_get_coarse_ns:
701                 return &bpf_ktime_get_coarse_ns_proto;
702         case BPF_FUNC_ringbuf_output:
703                 return &bpf_ringbuf_output_proto;
704         case BPF_FUNC_ringbuf_reserve:
705                 return &bpf_ringbuf_reserve_proto;
706         case BPF_FUNC_ringbuf_submit:
707                 return &bpf_ringbuf_submit_proto;
708         case BPF_FUNC_ringbuf_discard:
709                 return &bpf_ringbuf_discard_proto;
710         case BPF_FUNC_ringbuf_query:
711                 return &bpf_ringbuf_query_proto;
712         default:
713                 break;
714         }
715 
716         if (!bpf_capable())
717                 return NULL;
718 
719         switch (func_id) {
720         case BPF_FUNC_spin_lock:
721                 return &bpf_spin_lock_proto;
722         case BPF_FUNC_spin_unlock:
723                 return &bpf_spin_unlock_proto;
724         case BPF_FUNC_jiffies64:
725                 return &bpf_jiffies64_proto;
726         case BPF_FUNC_per_cpu_ptr:
727                 return &bpf_per_cpu_ptr_proto;
728         case BPF_FUNC_this_cpu_ptr:
729                 return &bpf_this_cpu_ptr_proto;
730         default:
731                 break;
732         }
733 
734         if (!perfmon_capable())
735                 return NULL;
736 
737         switch (func_id) {
738         case BPF_FUNC_trace_printk:
739                 return bpf_get_trace_printk_proto();
740         case BPF_FUNC_get_current_task:
741                 return &bpf_get_current_task_proto;
742         case BPF_FUNC_probe_read_user:
743                 return &bpf_probe_read_user_proto;
744         case BPF_FUNC_probe_read_kernel:
745                 return security_locked_down(LOCKDOWN_BPF_READ) < 0 ?
746                        NULL : &bpf_probe_read_kernel_proto;
747         case BPF_FUNC_probe_read_user_str:
748                 return &bpf_probe_read_user_str_proto;
749         case BPF_FUNC_probe_read_kernel_str:
750                 return security_locked_down(LOCKDOWN_BPF_READ) < 0 ?
751                        NULL : &bpf_probe_read_kernel_str_proto;
752         case BPF_FUNC_snprintf_btf:
753                 return &bpf_snprintf_btf_proto;
754         default:
755                 return NULL;
756         }
757 }
758 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp