1
2
3
4
5
6
7#ifndef _LINUX_BPF_H
8#define _LINUX_BPF_H 1
9
10#include <uapi/linux/bpf.h>
11
12#include <linux/workqueue.h>
13#include <linux/file.h>
14#include <linux/percpu.h>
15#include <linux/err.h>
16#include <linux/rbtree_latch.h>
17#include <linux/numa.h>
18#include <linux/wait.h>
19
20struct bpf_verifier_env;
21struct perf_event;
22struct bpf_prog;
23struct bpf_map;
24struct sock;
25struct seq_file;
26struct btf;
27
28
29struct bpf_map_ops {
30
31 int (*map_alloc_check)(union bpf_attr *attr);
32 struct bpf_map *(*map_alloc)(union bpf_attr *attr);
33 void (*map_release)(struct bpf_map *map, struct file *map_file);
34 void (*map_free)(struct bpf_map *map);
35 int (*map_get_next_key)(struct bpf_map *map, void *key, void *next_key);
36 void (*map_release_uref)(struct bpf_map *map);
37
38
39 void *(*map_lookup_elem)(struct bpf_map *map, void *key);
40 int (*map_update_elem)(struct bpf_map *map, void *key, void *value, u64 flags);
41 int (*map_delete_elem)(struct bpf_map *map, void *key);
42
43
44 void *(*map_fd_get_ptr)(struct bpf_map *map, struct file *map_file,
45 int fd);
46 void (*map_fd_put_ptr)(void *ptr);
47 u32 (*map_gen_lookup)(struct bpf_map *map, struct bpf_insn *insn_buf);
48 u32 (*map_fd_sys_lookup_elem)(void *ptr);
49 void (*map_seq_show_elem)(struct bpf_map *map, void *key,
50 struct seq_file *m);
51 int (*map_check_btf)(const struct bpf_map *map, const struct btf *btf,
52 u32 key_type_id, u32 value_type_id);
53};
54
55struct bpf_map {
56
57
58
59 const struct bpf_map_ops *ops ____cacheline_aligned;
60 struct bpf_map *inner_map_meta;
61#ifdef CONFIG_SECURITY
62 void *security;
63#endif
64 enum bpf_map_type map_type;
65 u32 key_size;
66 u32 value_size;
67 u32 max_entries;
68 u32 map_flags;
69 u32 pages;
70 u32 id;
71 int numa_node;
72 u32 btf_key_type_id;
73 u32 btf_value_type_id;
74 struct btf *btf;
75 bool unpriv_array;
76
77
78
79
80
81 struct user_struct *user ____cacheline_aligned;
82 atomic_t refcnt;
83 atomic_t usercnt;
84 struct work_struct work;
85 char name[BPF_OBJ_NAME_LEN];
86};
87
88struct bpf_offloaded_map;
89
90struct bpf_map_dev_ops {
91 int (*map_get_next_key)(struct bpf_offloaded_map *map,
92 void *key, void *next_key);
93 int (*map_lookup_elem)(struct bpf_offloaded_map *map,
94 void *key, void *value);
95 int (*map_update_elem)(struct bpf_offloaded_map *map,
96 void *key, void *value, u64 flags);
97 int (*map_delete_elem)(struct bpf_offloaded_map *map, void *key);
98};
99
100struct bpf_offloaded_map {
101 struct bpf_map map;
102 struct net_device *netdev;
103 const struct bpf_map_dev_ops *dev_ops;
104 void *dev_priv;
105 struct list_head offloads;
106};
107
108static inline struct bpf_offloaded_map *map_to_offmap(struct bpf_map *map)
109{
110 return container_of(map, struct bpf_offloaded_map, map);
111}
112
113static inline bool bpf_map_offload_neutral(const struct bpf_map *map)
114{
115 return map->map_type == BPF_MAP_TYPE_PERF_EVENT_ARRAY;
116}
117
118static inline bool bpf_map_support_seq_show(const struct bpf_map *map)
119{
120 return map->ops->map_seq_show_elem && map->ops->map_check_btf;
121}
122
123extern const struct bpf_map_ops bpf_map_offload_ops;
124
125
126enum bpf_arg_type {
127 ARG_DONTCARE = 0,
128
129
130
131
132 ARG_CONST_MAP_PTR,
133 ARG_PTR_TO_MAP_KEY,
134 ARG_PTR_TO_MAP_VALUE,
135
136
137
138
139 ARG_PTR_TO_MEM,
140 ARG_PTR_TO_MEM_OR_NULL,
141 ARG_PTR_TO_UNINIT_MEM,
142
143
144
145
146 ARG_CONST_SIZE,
147 ARG_CONST_SIZE_OR_ZERO,
148
149 ARG_PTR_TO_CTX,
150 ARG_ANYTHING,
151};
152
153
154enum bpf_return_type {
155 RET_INTEGER,
156 RET_VOID,
157 RET_PTR_TO_MAP_VALUE_OR_NULL,
158};
159
160
161
162
163
164struct bpf_func_proto {
165 u64 (*func)(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);
166 bool gpl_only;
167 bool pkt_access;
168 enum bpf_return_type ret_type;
169 enum bpf_arg_type arg1_type;
170 enum bpf_arg_type arg2_type;
171 enum bpf_arg_type arg3_type;
172 enum bpf_arg_type arg4_type;
173 enum bpf_arg_type arg5_type;
174};
175
176
177
178
179
180struct bpf_context;
181
182enum bpf_access_type {
183 BPF_READ = 1,
184 BPF_WRITE = 2
185};
186
187
188
189
190
191
192
193
194
195
196
197enum bpf_reg_type {
198 NOT_INIT = 0,
199 SCALAR_VALUE,
200 PTR_TO_CTX,
201 CONST_PTR_TO_MAP,
202 PTR_TO_MAP_VALUE,
203 PTR_TO_MAP_VALUE_OR_NULL,
204 PTR_TO_STACK,
205 PTR_TO_PACKET_META,
206 PTR_TO_PACKET,
207 PTR_TO_PACKET_END,
208};
209
210
211
212
213struct bpf_insn_access_aux {
214 enum bpf_reg_type reg_type;
215 int ctx_field_size;
216};
217
218static inline void
219bpf_ctx_record_field_size(struct bpf_insn_access_aux *aux, u32 size)
220{
221 aux->ctx_field_size = size;
222}
223
224struct bpf_prog_ops {
225 int (*test_run)(struct bpf_prog *prog, const union bpf_attr *kattr,
226 union bpf_attr __user *uattr);
227};
228
229struct bpf_verifier_ops {
230
231 const struct bpf_func_proto *
232 (*get_func_proto)(enum bpf_func_id func_id,
233 const struct bpf_prog *prog);
234
235
236
237
238 bool (*is_valid_access)(int off, int size, enum bpf_access_type type,
239 const struct bpf_prog *prog,
240 struct bpf_insn_access_aux *info);
241 int (*gen_prologue)(struct bpf_insn *insn, bool direct_write,
242 const struct bpf_prog *prog);
243 int (*gen_ld_abs)(const struct bpf_insn *orig,
244 struct bpf_insn *insn_buf);
245 u32 (*convert_ctx_access)(enum bpf_access_type type,
246 const struct bpf_insn *src,
247 struct bpf_insn *dst,
248 struct bpf_prog *prog, u32 *target_size);
249};
250
251struct bpf_prog_offload_ops {
252 int (*insn_hook)(struct bpf_verifier_env *env,
253 int insn_idx, int prev_insn_idx);
254};
255
256struct bpf_prog_offload {
257 struct bpf_prog *prog;
258 struct net_device *netdev;
259 void *dev_priv;
260 struct list_head offloads;
261 bool dev_state;
262 const struct bpf_prog_offload_ops *dev_ops;
263 void *jited_image;
264 u32 jited_len;
265};
266
267struct bpf_prog_aux {
268 atomic_t refcnt;
269 u32 used_map_cnt;
270 u32 max_ctx_offset;
271 u32 stack_depth;
272 u32 id;
273 u32 func_cnt;
274 bool offload_requested;
275 struct bpf_prog **func;
276 void *jit_data;
277 struct latch_tree_node ksym_tnode;
278 struct list_head ksym_lnode;
279 const struct bpf_prog_ops *ops;
280 struct bpf_map **used_maps;
281 struct bpf_prog *prog;
282 struct user_struct *user;
283 u64 load_time;
284 char name[BPF_OBJ_NAME_LEN];
285#ifdef CONFIG_SECURITY
286 void *security;
287#endif
288 struct bpf_prog_offload *offload;
289 union {
290 struct work_struct work;
291 struct rcu_head rcu;
292 };
293};
294
295struct bpf_array {
296 struct bpf_map map;
297 u32 elem_size;
298 u32 index_mask;
299
300
301
302
303
304 enum bpf_prog_type owner_prog_type;
305 bool owner_jited;
306 union {
307 char value[0] __aligned(8);
308 void *ptrs[0] __aligned(8);
309 void __percpu *pptrs[0] __aligned(8);
310 };
311};
312
313#define MAX_TAIL_CALL_CNT 32
314
315struct bpf_event_entry {
316 struct perf_event *event;
317 struct file *perf_file;
318 struct file *map_file;
319 struct rcu_head rcu;
320};
321
322bool bpf_prog_array_compatible(struct bpf_array *array, const struct bpf_prog *fp);
323int bpf_prog_calc_tag(struct bpf_prog *fp);
324
325const struct bpf_func_proto *bpf_get_trace_printk_proto(void);
326
327typedef unsigned long (*bpf_ctx_copy_t)(void *dst, const void *src,
328 unsigned long off, unsigned long len);
329
330u64 bpf_event_output(struct bpf_map *map, u64 flags, void *meta, u64 meta_size,
331 void *ctx, u64 ctx_size, bpf_ctx_copy_t ctx_copy);
332
333int bpf_prog_test_run_xdp(struct bpf_prog *prog, const union bpf_attr *kattr,
334 union bpf_attr __user *uattr);
335int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr,
336 union bpf_attr __user *uattr);
337
338
339
340
341
342
343
344
345
346
347
348
349
350struct bpf_prog_array {
351 struct rcu_head rcu;
352 struct bpf_prog *progs[0];
353};
354
355struct bpf_prog_array __rcu *bpf_prog_array_alloc(u32 prog_cnt, gfp_t flags);
356void bpf_prog_array_free(struct bpf_prog_array __rcu *progs);
357int bpf_prog_array_length(struct bpf_prog_array __rcu *progs);
358int bpf_prog_array_copy_to_user(struct bpf_prog_array __rcu *progs,
359 __u32 __user *prog_ids, u32 cnt);
360
361void bpf_prog_array_delete_safe(struct bpf_prog_array __rcu *progs,
362 struct bpf_prog *old_prog);
363int bpf_prog_array_copy_info(struct bpf_prog_array __rcu *array,
364 u32 *prog_ids, u32 request_cnt,
365 u32 *prog_cnt);
366int bpf_prog_array_copy(struct bpf_prog_array __rcu *old_array,
367 struct bpf_prog *exclude_prog,
368 struct bpf_prog *include_prog,
369 struct bpf_prog_array **new_array);
370
371#define __BPF_PROG_RUN_ARRAY(array, ctx, func, check_non_null) \
372 ({ \
373 struct bpf_prog **_prog, *__prog; \
374 struct bpf_prog_array *_array; \
375 u32 _ret = 1; \
376 preempt_disable(); \
377 rcu_read_lock(); \
378 _array = rcu_dereference(array); \
379 if (unlikely(check_non_null && !_array))\
380 goto _out; \
381 _prog = _array->progs; \
382 while ((__prog = READ_ONCE(*_prog))) { \
383 _ret &= func(__prog, ctx); \
384 _prog++; \
385 } \
386_out: \
387 rcu_read_unlock(); \
388 preempt_enable_no_resched(); \
389 _ret; \
390 })
391
392#define BPF_PROG_RUN_ARRAY(array, ctx, func) \
393 __BPF_PROG_RUN_ARRAY(array, ctx, func, false)
394
395#define BPF_PROG_RUN_ARRAY_CHECK(array, ctx, func) \
396 __BPF_PROG_RUN_ARRAY(array, ctx, func, true)
397
398#ifdef CONFIG_BPF_SYSCALL
399DECLARE_PER_CPU(int, bpf_prog_active);
400
401extern const struct file_operations bpf_map_fops;
402extern const struct file_operations bpf_prog_fops;
403
404#define BPF_PROG_TYPE(_id, _name) \
405 extern const struct bpf_prog_ops _name ## _prog_ops; \
406 extern const struct bpf_verifier_ops _name ## _verifier_ops;
407#define BPF_MAP_TYPE(_id, _ops) \
408 extern const struct bpf_map_ops _ops;
409#include <linux/bpf_types.h>
410#undef BPF_PROG_TYPE
411#undef BPF_MAP_TYPE
412
413extern const struct bpf_prog_ops bpf_offload_prog_ops;
414extern const struct bpf_verifier_ops tc_cls_act_analyzer_ops;
415extern const struct bpf_verifier_ops xdp_analyzer_ops;
416
417struct bpf_prog *bpf_prog_get(u32 ufd);
418struct bpf_prog *bpf_prog_get_type_dev(u32 ufd, enum bpf_prog_type type,
419 bool attach_drv);
420struct bpf_prog * __must_check bpf_prog_add(struct bpf_prog *prog, int i);
421void bpf_prog_sub(struct bpf_prog *prog, int i);
422struct bpf_prog * __must_check bpf_prog_inc(struct bpf_prog *prog);
423struct bpf_prog * __must_check bpf_prog_inc_not_zero(struct bpf_prog *prog);
424void bpf_prog_put(struct bpf_prog *prog);
425int __bpf_prog_charge(struct user_struct *user, u32 pages);
426void __bpf_prog_uncharge(struct user_struct *user, u32 pages);
427
428void bpf_prog_free_id(struct bpf_prog *prog, bool do_idr_lock);
429void bpf_map_free_id(struct bpf_map *map, bool do_idr_lock);
430
431struct bpf_map *bpf_map_get_with_uref(u32 ufd);
432struct bpf_map *__bpf_map_get(struct fd f);
433struct bpf_map * __must_check bpf_map_inc(struct bpf_map *map, bool uref);
434void bpf_map_put_with_uref(struct bpf_map *map);
435void bpf_map_put(struct bpf_map *map);
436int bpf_map_precharge_memlock(u32 pages);
437void *bpf_map_area_alloc(size_t size, int numa_node);
438void bpf_map_area_free(void *base);
439void bpf_map_init_from_attr(struct bpf_map *map, union bpf_attr *attr);
440
441extern int sysctl_unprivileged_bpf_disabled;
442
443int bpf_map_new_fd(struct bpf_map *map, int flags);
444int bpf_prog_new_fd(struct bpf_prog *prog);
445
446int bpf_obj_pin_user(u32 ufd, const char __user *pathname);
447int bpf_obj_get_user(const char __user *pathname, int flags);
448
449int bpf_percpu_hash_copy(struct bpf_map *map, void *key, void *value);
450int bpf_percpu_array_copy(struct bpf_map *map, void *key, void *value);
451int bpf_percpu_hash_update(struct bpf_map *map, void *key, void *value,
452 u64 flags);
453int bpf_percpu_array_update(struct bpf_map *map, void *key, void *value,
454 u64 flags);
455
456int bpf_stackmap_copy(struct bpf_map *map, void *key, void *value);
457
458int bpf_fd_array_map_update_elem(struct bpf_map *map, struct file *map_file,
459 void *key, void *value, u64 map_flags);
460int bpf_fd_array_map_lookup_elem(struct bpf_map *map, void *key, u32 *value);
461int bpf_fd_htab_map_update_elem(struct bpf_map *map, struct file *map_file,
462 void *key, void *value, u64 map_flags);
463int bpf_fd_htab_map_lookup_elem(struct bpf_map *map, void *key, u32 *value);
464
465int bpf_get_file_flag(int flags);
466int bpf_check_uarg_tail_zero(void __user *uaddr, size_t expected_size,
467 size_t actual_size);
468
469
470
471
472
473
474
475static inline void bpf_long_memcpy(void *dst, const void *src, u32 size)
476{
477 const long *lsrc = src;
478 long *ldst = dst;
479
480 size /= sizeof(long);
481 while (size--)
482 *ldst++ = *lsrc++;
483}
484
485
486int bpf_check(struct bpf_prog **fp, union bpf_attr *attr);
487void bpf_patch_call_args(struct bpf_insn *insn, u32 stack_depth);
488
489
490struct xdp_buff;
491struct sk_buff;
492
493struct bpf_dtab_netdev *__dev_map_lookup_elem(struct bpf_map *map, u32 key);
494void __dev_map_insert_ctx(struct bpf_map *map, u32 index);
495void __dev_map_flush(struct bpf_map *map);
496int dev_map_enqueue(struct bpf_dtab_netdev *dst, struct xdp_buff *xdp,
497 struct net_device *dev_rx);
498int dev_map_generic_redirect(struct bpf_dtab_netdev *dst, struct sk_buff *skb,
499 struct bpf_prog *xdp_prog);
500
501struct bpf_cpu_map_entry *__cpu_map_lookup_elem(struct bpf_map *map, u32 key);
502void __cpu_map_insert_ctx(struct bpf_map *map, u32 index);
503void __cpu_map_flush(struct bpf_map *map);
504int cpu_map_enqueue(struct bpf_cpu_map_entry *rcpu, struct xdp_buff *xdp,
505 struct net_device *dev_rx);
506
507
508static inline int bpf_map_attr_numa_node(const union bpf_attr *attr)
509{
510 return (attr->map_flags & BPF_F_NUMA_NODE) ?
511 attr->numa_node : NUMA_NO_NODE;
512}
513
514struct bpf_prog *bpf_prog_get_type_path(const char *name, enum bpf_prog_type type);
515
516#else
517static inline struct bpf_prog *bpf_prog_get(u32 ufd)
518{
519 return ERR_PTR(-EOPNOTSUPP);
520}
521
522static inline struct bpf_prog *bpf_prog_get_type_dev(u32 ufd,
523 enum bpf_prog_type type,
524 bool attach_drv)
525{
526 return ERR_PTR(-EOPNOTSUPP);
527}
528
529static inline struct bpf_prog * __must_check bpf_prog_add(struct bpf_prog *prog,
530 int i)
531{
532 return ERR_PTR(-EOPNOTSUPP);
533}
534
535static inline void bpf_prog_sub(struct bpf_prog *prog, int i)
536{
537}
538
539static inline void bpf_prog_put(struct bpf_prog *prog)
540{
541}
542
543static inline struct bpf_prog * __must_check bpf_prog_inc(struct bpf_prog *prog)
544{
545 return ERR_PTR(-EOPNOTSUPP);
546}
547
548static inline struct bpf_prog *__must_check
549bpf_prog_inc_not_zero(struct bpf_prog *prog)
550{
551 return ERR_PTR(-EOPNOTSUPP);
552}
553
554static inline int __bpf_prog_charge(struct user_struct *user, u32 pages)
555{
556 return 0;
557}
558
559static inline void __bpf_prog_uncharge(struct user_struct *user, u32 pages)
560{
561}
562
563static inline int bpf_obj_get_user(const char __user *pathname, int flags)
564{
565 return -EOPNOTSUPP;
566}
567
568static inline struct net_device *__dev_map_lookup_elem(struct bpf_map *map,
569 u32 key)
570{
571 return NULL;
572}
573
574static inline void __dev_map_insert_ctx(struct bpf_map *map, u32 index)
575{
576}
577
578static inline void __dev_map_flush(struct bpf_map *map)
579{
580}
581
582struct xdp_buff;
583struct bpf_dtab_netdev;
584
585static inline
586int dev_map_enqueue(struct bpf_dtab_netdev *dst, struct xdp_buff *xdp,
587 struct net_device *dev_rx)
588{
589 return 0;
590}
591
592struct sk_buff;
593
594static inline int dev_map_generic_redirect(struct bpf_dtab_netdev *dst,
595 struct sk_buff *skb,
596 struct bpf_prog *xdp_prog)
597{
598 return 0;
599}
600
601static inline
602struct bpf_cpu_map_entry *__cpu_map_lookup_elem(struct bpf_map *map, u32 key)
603{
604 return NULL;
605}
606
607static inline void __cpu_map_insert_ctx(struct bpf_map *map, u32 index)
608{
609}
610
611static inline void __cpu_map_flush(struct bpf_map *map)
612{
613}
614
615static inline int cpu_map_enqueue(struct bpf_cpu_map_entry *rcpu,
616 struct xdp_buff *xdp,
617 struct net_device *dev_rx)
618{
619 return 0;
620}
621
622static inline struct bpf_prog *bpf_prog_get_type_path(const char *name,
623 enum bpf_prog_type type)
624{
625 return ERR_PTR(-EOPNOTSUPP);
626}
627#endif
628
629static inline struct bpf_prog *bpf_prog_get_type(u32 ufd,
630 enum bpf_prog_type type)
631{
632 return bpf_prog_get_type_dev(ufd, type, false);
633}
634
635bool bpf_prog_get_ok(struct bpf_prog *, enum bpf_prog_type *, bool);
636
637int bpf_prog_offload_compile(struct bpf_prog *prog);
638void bpf_prog_offload_destroy(struct bpf_prog *prog);
639int bpf_prog_offload_info_fill(struct bpf_prog_info *info,
640 struct bpf_prog *prog);
641
642int bpf_map_offload_info_fill(struct bpf_map_info *info, struct bpf_map *map);
643
644int bpf_map_offload_lookup_elem(struct bpf_map *map, void *key, void *value);
645int bpf_map_offload_update_elem(struct bpf_map *map,
646 void *key, void *value, u64 flags);
647int bpf_map_offload_delete_elem(struct bpf_map *map, void *key);
648int bpf_map_offload_get_next_key(struct bpf_map *map,
649 void *key, void *next_key);
650
651bool bpf_offload_dev_match(struct bpf_prog *prog, struct bpf_map *map);
652
653#if defined(CONFIG_NET) && defined(CONFIG_BPF_SYSCALL)
654int bpf_prog_offload_init(struct bpf_prog *prog, union bpf_attr *attr);
655
656static inline bool bpf_prog_is_dev_bound(const struct bpf_prog_aux *aux)
657{
658 return aux->offload_requested;
659}
660
661static inline bool bpf_map_is_dev_bound(struct bpf_map *map)
662{
663 return unlikely(map->ops == &bpf_map_offload_ops);
664}
665
666struct bpf_map *bpf_map_offload_map_alloc(union bpf_attr *attr);
667void bpf_map_offload_map_free(struct bpf_map *map);
668#else
669static inline int bpf_prog_offload_init(struct bpf_prog *prog,
670 union bpf_attr *attr)
671{
672 return -EOPNOTSUPP;
673}
674
675static inline bool bpf_prog_is_dev_bound(struct bpf_prog_aux *aux)
676{
677 return false;
678}
679
680static inline bool bpf_map_is_dev_bound(struct bpf_map *map)
681{
682 return false;
683}
684
685static inline struct bpf_map *bpf_map_offload_map_alloc(union bpf_attr *attr)
686{
687 return ERR_PTR(-EOPNOTSUPP);
688}
689
690static inline void bpf_map_offload_map_free(struct bpf_map *map)
691{
692}
693#endif
694
695#if defined(CONFIG_STREAM_PARSER) && defined(CONFIG_BPF_SYSCALL) && defined(CONFIG_INET)
696struct sock *__sock_map_lookup_elem(struct bpf_map *map, u32 key);
697struct sock *__sock_hash_lookup_elem(struct bpf_map *map, void *key);
698int sock_map_prog(struct bpf_map *map, struct bpf_prog *prog, u32 type);
699int sockmap_get_from_fd(const union bpf_attr *attr, int type,
700 struct bpf_prog *prog);
701#else
702static inline struct sock *__sock_map_lookup_elem(struct bpf_map *map, u32 key)
703{
704 return NULL;
705}
706
707static inline struct sock *__sock_hash_lookup_elem(struct bpf_map *map,
708 void *key)
709{
710 return NULL;
711}
712
713static inline int sock_map_prog(struct bpf_map *map,
714 struct bpf_prog *prog,
715 u32 type)
716{
717 return -EOPNOTSUPP;
718}
719
720static inline int sockmap_get_from_fd(const union bpf_attr *attr, int type,
721 struct bpf_prog *prog)
722{
723 return -EINVAL;
724}
725#endif
726
727#if defined(CONFIG_XDP_SOCKETS)
728struct xdp_sock;
729struct xdp_sock *__xsk_map_lookup_elem(struct bpf_map *map, u32 key);
730int __xsk_map_redirect(struct bpf_map *map, struct xdp_buff *xdp,
731 struct xdp_sock *xs);
732void __xsk_map_flush(struct bpf_map *map);
733#else
734struct xdp_sock;
735static inline struct xdp_sock *__xsk_map_lookup_elem(struct bpf_map *map,
736 u32 key)
737{
738 return NULL;
739}
740
741static inline int __xsk_map_redirect(struct bpf_map *map, struct xdp_buff *xdp,
742 struct xdp_sock *xs)
743{
744 return -EOPNOTSUPP;
745}
746
747static inline void __xsk_map_flush(struct bpf_map *map)
748{
749}
750#endif
751
752
753extern const struct bpf_func_proto bpf_map_lookup_elem_proto;
754extern const struct bpf_func_proto bpf_map_update_elem_proto;
755extern const struct bpf_func_proto bpf_map_delete_elem_proto;
756
757extern const struct bpf_func_proto bpf_get_prandom_u32_proto;
758extern const struct bpf_func_proto bpf_get_smp_processor_id_proto;
759extern const struct bpf_func_proto bpf_get_numa_node_id_proto;
760extern const struct bpf_func_proto bpf_tail_call_proto;
761extern const struct bpf_func_proto bpf_ktime_get_ns_proto;
762extern const struct bpf_func_proto bpf_get_current_pid_tgid_proto;
763extern const struct bpf_func_proto bpf_get_current_uid_gid_proto;
764extern const struct bpf_func_proto bpf_get_current_comm_proto;
765extern const struct bpf_func_proto bpf_get_stackid_proto;
766extern const struct bpf_func_proto bpf_get_stack_proto;
767extern const struct bpf_func_proto bpf_sock_map_update_proto;
768extern const struct bpf_func_proto bpf_sock_hash_update_proto;
769extern const struct bpf_func_proto bpf_get_current_cgroup_id_proto;
770
771
772void bpf_user_rnd_init_once(void);
773u64 bpf_user_rnd_u32(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);
774
775#endif
776