include/linux/bpf.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
   3  */
   4 #ifndef _LINUX_BPF_H
   5 #define _LINUX_BPF_H 1
   6
   7 #include <uapi/linux/bpf.h>
   8
   9 #include <linux/workqueue.h>
  10 #include <linux/file.h>
  11 #include <linux/percpu.h>
  12 #include <linux/err.h>
  13 #include <linux/rbtree_latch.h>
  14 #include <linux/numa.h>
  15 #include <linux/mm_types.h>
  16 #include <linux/wait.h>
  17 #include <linux/refcount.h>
  18 #include <linux/mutex.h>
  19 #include <linux/module.h>
  20 #include <linux/kallsyms.h>
  21 #include <linux/capability.h>
  22 #include <linux/sched/mm.h>
  23 #include <linux/slab.h>
  24 #include <linux/percpu-refcount.h>
  25 #include <linux/bpfptr.h>
  26
  27 struct bpf_verifier_env;
  28 struct bpf_verifier_log;
  29 struct perf_event;
  30 struct bpf_prog;
  31 struct bpf_prog_aux;
  32 struct bpf_map;
  33 struct sock;
  34 struct seq_file;
  35 struct btf;
  36 struct btf_type;
  37 struct exception_table_entry;
  38 struct seq_operations;
  39 struct bpf_iter_aux_info;
  40 struct bpf_local_storage;
  41 struct bpf_local_storage_map;
  42 struct kobject;
  43 struct mem_cgroup;
  44 struct module;
  45 struct bpf_func_state;
  46
  47 extern struct idr btf_idr;
  48 extern spinlock_t btf_idr_lock;
  49 extern struct kobject *btf_kobj;
  50
  51 typedef u64 (*bpf_callback_t)(u64, u64, u64, u64, u64);
  52 typedef int (*bpf_iter_init_seq_priv_t)(void *private_data,
  53                                         struct bpf_iter_aux_info *aux);
  54 typedef void (*bpf_iter_fini_seq_priv_t)(void *private_data);
  55 struct bpf_iter_seq_info {
  56         const struct seq_operations *seq_ops;
  57         bpf_iter_init_seq_priv_t init_seq_private;
  58         bpf_iter_fini_seq_priv_t fini_seq_private;
  59         u32 seq_priv_size;
  60 };
  61
  62 /* map is generic key/value storage optionally accessible by eBPF programs */
  63 struct bpf_map_ops {
  64         /* funcs callable from userspace (via syscall) */
  65         int (*map_alloc_check)(union bpf_attr *attr);
  66         struct bpf_map *(*map_alloc)(union bpf_attr *attr);
  67         void (*map_release)(struct bpf_map *map, struct file *map_file);
  68         void (*map_free)(struct bpf_map *map);
  69         int (*map_get_next_key)(struct bpf_map *map, void *key, void *next_key);
  70         void (*map_release_uref)(struct bpf_map *map);
  71         void *(*map_lookup_elem_sys_only)(struct bpf_map *map, void *key);
  72         int (*map_lookup_batch)(struct bpf_map *map, const union bpf_attr *attr,
  73                                 union bpf_attr __user *uattr);
  74         int (*map_lookup_and_delete_elem)(struct bpf_map *map, void *key,
  75                                           void *value, u64 flags);
  76         int (*map_lookup_and_delete_batch)(struct bpf_map *map,
  77                                            const union bpf_attr *attr,
  78                                            union bpf_attr __user *uattr);
  79         int (*map_update_batch)(struct bpf_map *map, const union bpf_attr *attr,
  80                                 union bpf_attr __user *uattr);
  81         int (*map_delete_batch)(struct bpf_map *map, const union bpf_attr *attr,
  82                                 union bpf_attr __user *uattr);
  83
  84         /* funcs callable from userspace and from eBPF programs */
  85         void *(*map_lookup_elem)(struct bpf_map *map, void *key);
  86         int (*map_update_elem)(struct bpf_map *map, void *key, void *value, u64 flags);
  87         int (*map_delete_elem)(struct bpf_map *map, void *key);
  88         int (*map_push_elem)(struct bpf_map *map, void *value, u64 flags);
  89         int (*map_pop_elem)(struct bpf_map *map, void *value);
  90         int (*map_peek_elem)(struct bpf_map *map, void *value);
  91
  92         /* funcs called by prog_array and perf_event_array map */
  93         void *(*map_fd_get_ptr)(struct bpf_map *map, struct file *map_file,
  94                                 int fd);
  95         void (*map_fd_put_ptr)(void *ptr);
  96         int (*map_gen_lookup)(struct bpf_map *map, struct bpf_insn *insn_buf);
  97         u32 (*map_fd_sys_lookup_elem)(void *ptr);
  98         void (*map_seq_show_elem)(struct bpf_map *map, void *key,
  99                                   struct seq_file *m);
 100         int (*map_check_btf)(const struct bpf_map *map,
 101                              const struct btf *btf,
 102                              const struct btf_type *key_type,
 103                              const struct btf_type *value_type);
 104
 105         /* Prog poke tracking helpers. */
 106         int (*map_poke_track)(struct bpf_map *map, struct bpf_prog_aux *aux);
 107         void (*map_poke_untrack)(struct bpf_map *map, struct bpf_prog_aux *aux);
 108         void (*map_poke_run)(struct bpf_map *map, u32 key, struct bpf_prog *old,
 109                              struct bpf_prog *new);
 110
 111         /* Direct value access helpers. */
 112         int (*map_direct_value_addr)(const struct bpf_map *map,
 113                                      u64 *imm, u32 off);
 114         int (*map_direct_value_meta)(const struct bpf_map *map,
 115                                      u64 imm, u32 *off);
 116         int (*map_mmap)(struct bpf_map *map, struct vm_area_struct *vma);
 117         __poll_t (*map_poll)(struct bpf_map *map, struct file *filp,
 118                              struct poll_table_struct *pts);
 119
 120         /* Functions called by bpf_local_storage maps */
 121         int (*map_local_storage_charge)(struct bpf_local_storage_map *smap,
 122                                         void *owner, u32 size);
 123         void (*map_local_storage_uncharge)(struct bpf_local_storage_map *smap,
 124                                            void *owner, u32 size);
 125         struct bpf_local_storage __rcu ** (*map_owner_storage_ptr)(void *owner);
 126
 127         /* Misc helpers.*/
 128         int (*map_redirect)(struct bpf_map *map, u32 ifindex, u64 flags);
 129
 130         /* map_meta_equal must be implemented for maps that can be
 131          * used as an inner map.  It is a runtime check to ensure
 132          * an inner map can be inserted to an outer map.
 133          *
 134          * Some properties of the inner map has been used during the
 135          * verification time.  When inserting an inner map at the runtime,
 136          * map_meta_equal has to ensure the inserting map has the same
 137          * properties that the verifier has used earlier.
 138          */
 139         bool (*map_meta_equal)(const struct bpf_map *meta0,
 140                                const struct bpf_map *meta1);
 141
 142
 143         int (*map_set_for_each_callback_args)(struct bpf_verifier_env *env,
 144                                               struct bpf_func_state *caller,
 145                                               struct bpf_func_state *callee);
 146         int (*map_for_each_callback)(struct bpf_map *map,
 147                                      bpf_callback_t callback_fn,
 148                                      void *callback_ctx, u64 flags);
 149
 150         /* BTF name and id of struct allocated by map_alloc */
 151         const char * const map_btf_name;
 152         int *map_btf_id;
 153
 154         /* bpf_iter info used to open a seq_file */
 155         const struct bpf_iter_seq_info *iter_seq_info;
 156 };
 157
 158 struct bpf_map {
 159         /* The first two cachelines with read-mostly members of which some
 160          * are also accessed in fast-path (e.g. ops, max_entries).
 161          */
 162         const struct bpf_map_ops *ops ____cacheline_aligned;
 163         struct bpf_map *inner_map_meta;
 164 #ifdef CONFIG_SECURITY
 165         void *security;
 166 #endif
 167         enum bpf_map_type map_type;
 168         u32 key_size;
 169         u32 value_size;
 170         u32 max_entries;
 171         u64 map_extra; /* any per-map-type extra fields */
 172         u32 map_flags;
 173         int spin_lock_off; /* >=0 valid offset, <0 error */
 174         int timer_off; /* >=0 valid offset, <0 error */
 175         u32 id;
 176         int numa_node;
 177         u32 btf_key_type_id;
 178         u32 btf_value_type_id;
 179         u32 btf_vmlinux_value_type_id;
 180         struct btf *btf;
 181 #ifdef CONFIG_MEMCG_KMEM
 182         struct mem_cgroup *memcg;
 183 #endif
 184         char name[BPF_OBJ_NAME_LEN];
 185         bool bypass_spec_v1;
 186         bool frozen; /* write-once; write-protected by freeze_mutex */
 187         /* 14 bytes hole */
 188
 189         /* The 3rd and 4th cacheline with misc members to avoid false sharing
 190          * particularly with refcounting.
 191          */
 192         atomic64_t refcnt ____cacheline_aligned;
 193         atomic64_t usercnt;
 194         struct work_struct work;
 195         struct mutex freeze_mutex;
 196         atomic64_t writecnt;
 197 };
 198
 199 static inline bool map_value_has_spin_lock(const struct bpf_map *map)
 200 {
 201         return map->spin_lock_off >= 0;
 202 }
 203
 204 static inline bool map_value_has_timer(const struct bpf_map *map)
 205 {
 206         return map->timer_off >= 0;
 207 }
 208
 209 static inline void check_and_init_map_value(struct bpf_map *map, void *dst)
 210 {
 211         if (unlikely(map_value_has_spin_lock(map)))
 212                 *(struct bpf_spin_lock *)(dst + map->spin_lock_off) =
 213                         (struct bpf_spin_lock){};
 214         if (unlikely(map_value_has_timer(map)))
 215                 *(struct bpf_timer *)(dst + map->timer_off) =
 216                         (struct bpf_timer){};
 217 }
 218
 219 /* copy everything but bpf_spin_lock and bpf_timer. There could be one of each. */
 220 static inline void copy_map_value(struct bpf_map *map, void *dst, void *src)
 221 {
 222         u32 s_off = 0, s_sz = 0, t_off = 0, t_sz = 0;
 223
 224         if (unlikely(map_value_has_spin_lock(map))) {
 225                 s_off = map->spin_lock_off;
 226                 s_sz = sizeof(struct bpf_spin_lock);
 227         } else if (unlikely(map_value_has_timer(map))) {
 228                 t_off = map->timer_off;
 229                 t_sz = sizeof(struct bpf_timer);
 230         }
 231
 232         if (unlikely(s_sz || t_sz)) {
 233                 if (s_off < t_off || !s_sz) {
 234                         swap(s_off, t_off);
 235                         swap(s_sz, t_sz);
 236                 }
 237                 memcpy(dst, src, t_off);
 238                 memcpy(dst + t_off + t_sz,
 239                        src + t_off + t_sz,
 240                        s_off - t_off - t_sz);
 241                 memcpy(dst + s_off + s_sz,
 242                        src + s_off + s_sz,
 243                        map->value_size - s_off - s_sz);
 244         } else {
 245                 memcpy(dst, src, map->value_size);
 246         }
 247 }
 248 void copy_map_value_locked(struct bpf_map *map, void *dst, void *src,
 249                            bool lock_src);
 250 void bpf_timer_cancel_and_free(void *timer);
 251 int bpf_obj_name_cpy(char *dst, const char *src, unsigned int size);
 252
 253 struct bpf_offload_dev;
 254 struct bpf_offloaded_map;
 255
 256 struct bpf_map_dev_ops {
 257         int (*map_get_next_key)(struct bpf_offloaded_map *map,
 258                                 void *key, void *next_key);
 259         int (*map_lookup_elem)(struct bpf_offloaded_map *map,
 260                                void *key, void *value);
 261         int (*map_update_elem)(struct bpf_offloaded_map *map,
 262                                void *key, void *value, u64 flags);
 263         int (*map_delete_elem)(struct bpf_offloaded_map *map, void *key);
 264 };
 265
 266 struct bpf_offloaded_map {
 267         struct bpf_map map;
 268         struct net_device *netdev;
 269         const struct bpf_map_dev_ops *dev_ops;
 270         void *dev_priv;
 271         struct list_head offloads;
 272 };
 273
 274 static inline struct bpf_offloaded_map *map_to_offmap(struct bpf_map *map)
 275 {
 276         return container_of(map, struct bpf_offloaded_map, map);
 277 }
 278
 279 static inline bool bpf_map_offload_neutral(const struct bpf_map *map)
 280 {
 281         return map->map_type == BPF_MAP_TYPE_PERF_EVENT_ARRAY;
 282 }
 283
 284 static inline bool bpf_map_support_seq_show(const struct bpf_map *map)
 285 {
 286         return (map->btf_value_type_id || map->btf_vmlinux_value_type_id) &&
 287                 map->ops->map_seq_show_elem;
 288 }
 289
 290 int map_check_no_btf(const struct bpf_map *map,
 291                      const struct btf *btf,
 292                      const struct btf_type *key_type,
 293                      const struct btf_type *value_type);
 294
 295 bool bpf_map_meta_equal(const struct bpf_map *meta0,
 296                         const struct bpf_map *meta1);
 297
 298 extern const struct bpf_map_ops bpf_map_offload_ops;
 299
 300 /* bpf_type_flag contains a set of flags that are applicable to the values of
 301  * arg_type, ret_type and reg_type. For example, a pointer value may be null,
 302  * or a memory is read-only. We classify types into two categories: base types
 303  * and extended types. Extended types are base types combined with a type flag.
 304  *
 305  * Currently there are no more than 32 base types in arg_type, ret_type and
 306  * reg_types.
 307  */
 308 #define BPF_BASE_TYPE_BITS      8
 309
 310 enum bpf_type_flag {
 311         /* PTR may be NULL. */
 312         PTR_MAYBE_NULL          = BIT(0 + BPF_BASE_TYPE_BITS),
 313
 314         /* MEM is read-only. When applied on bpf_arg, it indicates the arg is
 315          * compatible with both mutable and immutable memory.
 316          */
 317         MEM_RDONLY              = BIT(1 + BPF_BASE_TYPE_BITS),
 318
 319         __BPF_TYPE_LAST_FLAG    = MEM_RDONLY,
 320 };
 321
 322 /* Max number of base types. */
 323 #define BPF_BASE_TYPE_LIMIT     (1UL << BPF_BASE_TYPE_BITS)
 324
 325 /* Max number of all types. */
 326 #define BPF_TYPE_LIMIT          (__BPF_TYPE_LAST_FLAG | (__BPF_TYPE_LAST_FLAG - 1))
 327
 328 /* function argument constraints */
 329 enum bpf_arg_type {
 330         ARG_DONTCARE = 0,       /* unused argument in helper function */
 331
 332         /* the following constraints used to prototype
 333          * bpf_map_lookup/update/delete_elem() functions
 334          */
 335         ARG_CONST_MAP_PTR,      /* const argument used as pointer to bpf_map */
 336         ARG_PTR_TO_MAP_KEY,     /* pointer to stack used as map key */
 337         ARG_PTR_TO_MAP_VALUE,   /* pointer to stack used as map value */
 338         ARG_PTR_TO_UNINIT_MAP_VALUE,    /* pointer to valid memory used to store a map value */
 339
 340         /* the following constraints used to prototype bpf_memcmp() and other
 341          * functions that access data on eBPF program stack
 342          */
 343         ARG_PTR_TO_MEM,         /* pointer to valid memory (stack, packet, map value) */
 344         ARG_PTR_TO_UNINIT_MEM,  /* pointer to memory does not need to be initialized,
 345                                  * helper function must fill all bytes or clear
 346                                  * them in error case.
 347                                  */
 348
 349         ARG_CONST_SIZE,         /* number of bytes accessed from memory */
 350         ARG_CONST_SIZE_OR_ZERO, /* number of bytes accessed from memory or 0 */
 351
 352         ARG_PTR_TO_CTX,         /* pointer to context */
 353         ARG_ANYTHING,           /* any (initialized) argument is ok */
 354         ARG_PTR_TO_SPIN_LOCK,   /* pointer to bpf_spin_lock */
 355         ARG_PTR_TO_SOCK_COMMON, /* pointer to sock_common */
 356         ARG_PTR_TO_INT,         /* pointer to int */
 357         ARG_PTR_TO_LONG,        /* pointer to long */
 358         ARG_PTR_TO_SOCKET,      /* pointer to bpf_sock (fullsock) */
 359         ARG_PTR_TO_BTF_ID,      /* pointer to in-kernel struct */
 360         ARG_PTR_TO_ALLOC_MEM,   /* pointer to dynamically allocated memory */
 361         ARG_CONST_ALLOC_SIZE_OR_ZERO,   /* number of allocated bytes requested */
 362         ARG_PTR_TO_BTF_ID_SOCK_COMMON,  /* pointer to in-kernel sock_common or bpf-mirrored bpf_sock */
 363         ARG_PTR_TO_PERCPU_BTF_ID,       /* pointer to in-kernel percpu type */
 364         ARG_PTR_TO_FUNC,        /* pointer to a bpf program function */
 365         ARG_PTR_TO_STACK,       /* pointer to stack */
 366         ARG_PTR_TO_CONST_STR,   /* pointer to a null terminated read-only string */
 367         ARG_PTR_TO_TIMER,       /* pointer to bpf_timer */
 368         __BPF_ARG_TYPE_MAX,
 369
 370         /* Extended arg_types. */
 371         ARG_PTR_TO_MAP_VALUE_OR_NULL    = PTR_MAYBE_NULL | ARG_PTR_TO_MAP_VALUE,
 372         ARG_PTR_TO_MEM_OR_NULL          = PTR_MAYBE_NULL | ARG_PTR_TO_MEM,
 373         ARG_PTR_TO_CTX_OR_NULL          = PTR_MAYBE_NULL | ARG_PTR_TO_CTX,
 374         ARG_PTR_TO_SOCKET_OR_NULL       = PTR_MAYBE_NULL | ARG_PTR_TO_SOCKET,
 375         ARG_PTR_TO_ALLOC_MEM_OR_NULL    = PTR_MAYBE_NULL | ARG_PTR_TO_ALLOC_MEM,
 376         ARG_PTR_TO_STACK_OR_NULL        = PTR_MAYBE_NULL | ARG_PTR_TO_STACK,
 377
 378         /* This must be the last entry. Its purpose is to ensure the enum is
 379          * wide enough to hold the higher bits reserved for bpf_type_flag.
 380          */
 381         __BPF_ARG_TYPE_LIMIT    = BPF_TYPE_LIMIT,
 382 };
 383 static_assert(__BPF_ARG_TYPE_MAX <= BPF_BASE_TYPE_LIMIT);
 384
 385 /* type of values returned from helper functions */
 386 enum bpf_return_type {
 387         RET_INTEGER,                    /* function returns integer */
 388         RET_VOID,                       /* function doesn't return anything */
 389         RET_PTR_TO_MAP_VALUE,           /* returns a pointer to map elem value */
 390         RET_PTR_TO_SOCKET,              /* returns a pointer to a socket */
 391         RET_PTR_TO_TCP_SOCK,            /* returns a pointer to a tcp_sock */
 392         RET_PTR_TO_SOCK_COMMON,         /* returns a pointer to a sock_common */
 393         RET_PTR_TO_ALLOC_MEM,           /* returns a pointer to dynamically allocated memory */
 394         RET_PTR_TO_MEM_OR_BTF_ID,       /* returns a pointer to a valid memory or a btf_id */
 395         RET_PTR_TO_BTF_ID,              /* returns a pointer to a btf_id */
 396         __BPF_RET_TYPE_MAX,
 397
 398         /* Extended ret_types. */
 399         RET_PTR_TO_MAP_VALUE_OR_NULL    = PTR_MAYBE_NULL | RET_PTR_TO_MAP_VALUE,
 400         RET_PTR_TO_SOCKET_OR_NULL       = PTR_MAYBE_NULL | RET_PTR_TO_SOCKET,
 401         RET_PTR_TO_TCP_SOCK_OR_NULL     = PTR_MAYBE_NULL | RET_PTR_TO_TCP_SOCK,
 402         RET_PTR_TO_SOCK_COMMON_OR_NULL  = PTR_MAYBE_NULL | RET_PTR_TO_SOCK_COMMON,
 403         RET_PTR_TO_ALLOC_MEM_OR_NULL    = PTR_MAYBE_NULL | RET_PTR_TO_ALLOC_MEM,
 404         RET_PTR_TO_BTF_ID_OR_NULL       = PTR_MAYBE_NULL | RET_PTR_TO_BTF_ID,
 405
 406         /* This must be the last entry. Its purpose is to ensure the enum is
 407          * wide enough to hold the higher bits reserved for bpf_type_flag.
 408          */
 409         __BPF_RET_TYPE_LIMIT    = BPF_TYPE_LIMIT,
 410 };
 411 static_assert(__BPF_RET_TYPE_MAX <= BPF_BASE_TYPE_LIMIT);
 412
 413 /* eBPF function prototype used by verifier to allow BPF_CALLs from eBPF programs
 414  * to in-kernel helper functions and for adjusting imm32 field in BPF_CALL
 415  * instructions after verifying
 416  */
 417 struct bpf_func_proto {
 418         u64 (*func)(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);
 419         bool gpl_only;
 420         bool pkt_access;
 421         enum bpf_return_type ret_type;
 422         union {
 423                 struct {
 424                         enum bpf_arg_type arg1_type;
 425                         enum bpf_arg_type arg2_type;
 426                         enum bpf_arg_type arg3_type;
 427                         enum bpf_arg_type arg4_type;
 428                         enum bpf_arg_type arg5_type;
 429                 };
 430                 enum bpf_arg_type arg_type[5];
 431         };
 432         union {
 433                 struct {
 434                         u32 *arg1_btf_id;
 435                         u32 *arg2_btf_id;
 436                         u32 *arg3_btf_id;
 437                         u32 *arg4_btf_id;
 438                         u32 *arg5_btf_id;
 439                 };
 440                 u32 *arg_btf_id[5];
 441         };
 442         int *ret_btf_id; /* return value btf_id */
 443         bool (*allowed)(const struct bpf_prog *prog);
 444 };
 445
 446 /* bpf_context is intentionally undefined structure. Pointer to bpf_context is
 447  * the first argument to eBPF programs.
 448  * For socket filters: 'struct bpf_context *' == 'struct sk_buff *'
 449  */
 450 struct bpf_context;
 451
 452 enum bpf_access_type {
 453         BPF_READ = 1,
 454         BPF_WRITE = 2
 455 };
 456
 457 /* types of values stored in eBPF registers */
 458 /* Pointer types represent:
 459  * pointer
 460  * pointer + imm
 461  * pointer + (u16) var
 462  * pointer + (u16) var + imm
 463  * if (range > 0) then [ptr, ptr + range - off) is safe to access
 464  * if (id > 0) means that some 'var' was added
 465  * if (off > 0) means that 'imm' was added
 466  */
 467 enum bpf_reg_type {
 468         NOT_INIT = 0,            /* nothing was written into register */
 469         SCALAR_VALUE,            /* reg doesn't contain a valid pointer */
 470         PTR_TO_CTX,              /* reg points to bpf_context */
 471         CONST_PTR_TO_MAP,        /* reg points to struct bpf_map */
 472         PTR_TO_MAP_VALUE,        /* reg points to map element value */
 473         PTR_TO_MAP_KEY,          /* reg points to a map element key */
 474         PTR_TO_STACK,            /* reg == frame_pointer + offset */
 475         PTR_TO_PACKET_META,      /* skb->data - meta_len */
 476         PTR_TO_PACKET,           /* reg points to skb->data */
 477         PTR_TO_PACKET_END,       /* skb->data + headlen */
 478         PTR_TO_FLOW_KEYS,        /* reg points to bpf_flow_keys */
 479         PTR_TO_SOCKET,           /* reg points to struct bpf_sock */
 480         PTR_TO_SOCK_COMMON,      /* reg points to sock_common */
 481         PTR_TO_TCP_SOCK,         /* reg points to struct tcp_sock */
 482         PTR_TO_TP_BUFFER,        /* reg points to a writable raw tp's buffer */
 483         PTR_TO_XDP_SOCK,         /* reg points to struct xdp_sock */
 484         /* PTR_TO_BTF_ID points to a kernel struct that does not need
 485          * to be null checked by the BPF program. This does not imply the
 486          * pointer is _not_ null and in practice this can easily be a null
 487          * pointer when reading pointer chains. The assumption is program
 488          * context will handle null pointer dereference typically via fault
 489          * handling. The verifier must keep this in mind and can make no
 490          * assumptions about null or non-null when doing branch analysis.
 491          * Further, when passed into helpers the helpers can not, without
 492          * additional context, assume the value is non-null.
 493          */
 494         PTR_TO_BTF_ID,
 495         /* PTR_TO_BTF_ID_OR_NULL points to a kernel struct that has not
 496          * been checked for null. Used primarily to inform the verifier
 497          * an explicit null check is required for this struct.
 498          */
 499         PTR_TO_MEM,              /* reg points to valid memory region */
 500         PTR_TO_BUF,              /* reg points to a read/write buffer */
 501         PTR_TO_PERCPU_BTF_ID,    /* reg points to a percpu kernel variable */
 502         PTR_TO_FUNC,             /* reg points to a bpf program function */
 503         __BPF_REG_TYPE_MAX,
 504
 505         /* Extended reg_types. */
 506         PTR_TO_MAP_VALUE_OR_NULL        = PTR_MAYBE_NULL | PTR_TO_MAP_VALUE,
 507         PTR_TO_SOCKET_OR_NULL           = PTR_MAYBE_NULL | PTR_TO_SOCKET,
 508         PTR_TO_SOCK_COMMON_OR_NULL      = PTR_MAYBE_NULL | PTR_TO_SOCK_COMMON,
 509         PTR_TO_TCP_SOCK_OR_NULL         = PTR_MAYBE_NULL | PTR_TO_TCP_SOCK,
 510         PTR_TO_BTF_ID_OR_NULL           = PTR_MAYBE_NULL | PTR_TO_BTF_ID,
 511
 512         /* This must be the last entry. Its purpose is to ensure the enum is
 513          * wide enough to hold the higher bits reserved for bpf_type_flag.
 514          */
 515         __BPF_REG_TYPE_LIMIT    = BPF_TYPE_LIMIT,
 516 };
 517 static_assert(__BPF_REG_TYPE_MAX <= BPF_BASE_TYPE_LIMIT);
 518
 519 /* The information passed from prog-specific *_is_valid_access
 520  * back to the verifier.
 521  */
 522 struct bpf_insn_access_aux {
 523         enum bpf_reg_type reg_type;
 524         union {
 525                 int ctx_field_size;
 526                 struct {
 527                         struct btf *btf;
 528                         u32 btf_id;
 529                 };
 530         };
 531         struct bpf_verifier_log *log; /* for verbose logs */
 532 };
 533
 534 static inline void
 535 bpf_ctx_record_field_size(struct bpf_insn_access_aux *aux, u32 size)
 536 {
 537         aux->ctx_field_size = size;
 538 }
 539
 540 static inline bool bpf_pseudo_func(const struct bpf_insn *insn)
 541 {
 542         return insn->code == (BPF_LD | BPF_IMM | BPF_DW) &&
 543                insn->src_reg == BPF_PSEUDO_FUNC;
 544 }
 545
 546 struct bpf_prog_ops {
 547         int (*test_run)(struct bpf_prog *prog, const union bpf_attr *kattr,
 548                         union bpf_attr __user *uattr);
 549 };
 550
 551 struct bpf_verifier_ops {
 552         /* return eBPF function prototype for verification */
 553         const struct bpf_func_proto *
 554         (*get_func_proto)(enum bpf_func_id func_id,
 555                           const struct bpf_prog *prog);
 556
 557         /* return true if 'size' wide access at offset 'off' within bpf_context
 558          * with 'type' (read or write) is allowed
 559          */
 560         bool (*is_valid_access)(int off, int size, enum bpf_access_type type,
 561                                 const struct bpf_prog *prog,
 562                                 struct bpf_insn_access_aux *info);
 563         int (*gen_prologue)(struct bpf_insn *insn, bool direct_write,
 564                             const struct bpf_prog *prog);
 565         int (*gen_ld_abs)(const struct bpf_insn *orig,
 566                           struct bpf_insn *insn_buf);
 567         u32 (*convert_ctx_access)(enum bpf_access_type type,
 568                                   const struct bpf_insn *src,
 569                                   struct bpf_insn *dst,
 570                                   struct bpf_prog *prog, u32 *target_size);
 571         int (*btf_struct_access)(struct bpf_verifier_log *log,
 572                                  const struct btf *btf,
 573                                  const struct btf_type *t, int off, int size,
 574                                  enum bpf_access_type atype,
 575                                  u32 *next_btf_id);
 576         bool (*check_kfunc_call)(u32 kfunc_btf_id, struct module *owner);
 577 };
 578
 579 struct bpf_prog_offload_ops {
 580         /* verifier basic callbacks */
 581         int (*insn_hook)(struct bpf_verifier_env *env,
 582                          int insn_idx, int prev_insn_idx);
 583         int (*finalize)(struct bpf_verifier_env *env);
 584         /* verifier optimization callbacks (called after .finalize) */
 585         int (*replace_insn)(struct bpf_verifier_env *env, u32 off,
 586                             struct bpf_insn *insn);
 587         int (*remove_insns)(struct bpf_verifier_env *env, u32 off, u32 cnt);
 588         /* program management callbacks */
 589         int (*prepare)(struct bpf_prog *prog);
 590         int (*translate)(struct bpf_prog *prog);
 591         void (*destroy)(struct bpf_prog *prog);
 592 };
 593
 594 struct bpf_prog_offload {
 595         struct bpf_prog         *prog;
 596         struct net_device       *netdev;
 597         struct bpf_offload_dev  *offdev;
 598         void                    *dev_priv;
 599         struct list_head        offloads;
 600         bool                    dev_state;
 601         bool                    opt_failed;
 602         void                    *jited_image;
 603         u32                     jited_len;
 604 };
 605
 606 enum bpf_cgroup_storage_type {
 607         BPF_CGROUP_STORAGE_SHARED,
 608         BPF_CGROUP_STORAGE_PERCPU,
 609         __BPF_CGROUP_STORAGE_MAX
 610 };
 611
 612 #define MAX_BPF_CGROUP_STORAGE_TYPE __BPF_CGROUP_STORAGE_MAX
 613
 614 /* The longest tracepoint has 12 args.
 615  * See include/trace/bpf_probe.h
 616  */
 617 #define MAX_BPF_FUNC_ARGS 12
 618
 619 /* The maximum number of arguments passed through registers
 620  * a single function may have.
 621  */
 622 #define MAX_BPF_FUNC_REG_ARGS 5
 623
 624 struct btf_func_model {
 625         u8 ret_size;
 626         u8 nr_args;
 627         u8 arg_size[MAX_BPF_FUNC_ARGS];
 628 };
 629
 630 /* Restore arguments before returning from trampoline to let original function
 631  * continue executing. This flag is used for fentry progs when there are no
 632  * fexit progs.
 633  */
 634 #define BPF_TRAMP_F_RESTORE_REGS        BIT(0)
 635 /* Call original function after fentry progs, but before fexit progs.
 636  * Makes sense for fentry/fexit, normal calls and indirect calls.
 637  */
 638 #define BPF_TRAMP_F_CALL_ORIG           BIT(1)
 639 /* Skip current frame and return to parent.  Makes sense for fentry/fexit
 640  * programs only. Should not be used with normal calls and indirect calls.
 641  */
 642 #define BPF_TRAMP_F_SKIP_FRAME          BIT(2)
 643 /* Store IP address of the caller on the trampoline stack,
 644  * so it's available for trampoline's programs.
 645  */
 646 #define BPF_TRAMP_F_IP_ARG              BIT(3)
 647 /* Return the return value of fentry prog. Only used by bpf_struct_ops. */
 648 #define BPF_TRAMP_F_RET_FENTRY_RET      BIT(4)
 649
 650 /* Each call __bpf_prog_enter + call bpf_func + call __bpf_prog_exit is ~50
 651  * bytes on x86.  Pick a number to fit into BPF_IMAGE_SIZE / 2
 652  */
 653 #define BPF_MAX_TRAMP_PROGS 38
 654
 655 struct bpf_tramp_progs {
 656         struct bpf_prog *progs[BPF_MAX_TRAMP_PROGS];
 657         int nr_progs;
 658 };
 659
 660 /* Different use cases for BPF trampoline:
 661  * 1. replace nop at the function entry (kprobe equivalent)
 662  *    flags = BPF_TRAMP_F_RESTORE_REGS
 663  *    fentry = a set of programs to run before returning from trampoline
 664  *
 665  * 2. replace nop at the function entry (kprobe + kretprobe equivalent)
 666  *    flags = BPF_TRAMP_F_CALL_ORIG | BPF_TRAMP_F_SKIP_FRAME
 667  *    orig_call = fentry_ip + MCOUNT_INSN_SIZE
 668  *    fentry = a set of program to run before calling original function
 669  *    fexit = a set of program to run after original function
 670  *
 671  * 3. replace direct call instruction anywhere in the function body
 672  *    or assign a function pointer for indirect call (like tcp_congestion_ops->cong_avoid)
 673  *    With flags = 0
 674  *      fentry = a set of programs to run before returning from trampoline
 675  *    With flags = BPF_TRAMP_F_CALL_ORIG
 676  *      orig_call = original callback addr or direct function addr
 677  *      fentry = a set of program to run before calling original function
 678  *      fexit = a set of program to run after original function
 679  */
 680 struct bpf_tramp_image;
 681 int arch_prepare_bpf_trampoline(struct bpf_tramp_image *tr, void *image, void *image_end,
 682                                 const struct btf_func_model *m, u32 flags,
 683                                 struct bpf_tramp_progs *tprogs,
 684                                 void *orig_call);
 685 /* these two functions are called from generated trampoline */
 686 u64 notrace __bpf_prog_enter(struct bpf_prog *prog);
 687 void notrace __bpf_prog_exit(struct bpf_prog *prog, u64 start);
 688 u64 notrace __bpf_prog_enter_sleepable(struct bpf_prog *prog);
 689 void notrace __bpf_prog_exit_sleepable(struct bpf_prog *prog, u64 start);
 690 void notrace __bpf_tramp_enter(struct bpf_tramp_image *tr);
 691 void notrace __bpf_tramp_exit(struct bpf_tramp_image *tr);
 692
 693 struct bpf_ksym {
 694         unsigned long            start;
 695         unsigned long            end;
 696         char                     name[KSYM_NAME_LEN];
 697         struct list_head         lnode;
 698         struct latch_tree_node   tnode;
 699         bool                     prog;
 700 };
 701
 702 enum bpf_tramp_prog_type {
 703         BPF_TRAMP_FENTRY,
 704         BPF_TRAMP_FEXIT,
 705         BPF_TRAMP_MODIFY_RETURN,
 706         BPF_TRAMP_MAX,
 707         BPF_TRAMP_REPLACE, /* more than MAX */
 708 };
 709
 710 struct bpf_tramp_image {
 711         void *image;
 712         struct bpf_ksym ksym;
 713         struct percpu_ref pcref;
 714         void *ip_after_call;
 715         void *ip_epilogue;
 716         union {
 717                 struct rcu_head rcu;
 718                 struct work_struct work;
 719         };
 720 };
 721
 722 struct bpf_trampoline {
 723         /* hlist for trampoline_table */
 724         struct hlist_node hlist;
 725         /* serializes access to fields of this trampoline */
 726         struct mutex mutex;
 727         refcount_t refcnt;
 728         u64 key;
 729         struct {
 730                 struct btf_func_model model;
 731                 void *addr;
 732                 bool ftrace_managed;
 733         } func;
 734         /* if !NULL this is BPF_PROG_TYPE_EXT program that extends another BPF
 735          * program by replacing one of its functions. func.addr is the address
 736          * of the function it replaced.
 737          */
 738         struct bpf_prog *extension_prog;
 739         /* list of BPF programs using this trampoline */
 740         struct hlist_head progs_hlist[BPF_TRAMP_MAX];
 741         /* Number of attached programs. A counter per kind. */
 742         int progs_cnt[BPF_TRAMP_MAX];
 743         /* Executable image of trampoline */
 744         struct bpf_tramp_image *cur_image;
 745         u64 selector;
 746         struct module *mod;
 747 };
 748
 749 struct bpf_attach_target_info {
 750         struct btf_func_model fmodel;
 751         long tgt_addr;
 752         const char *tgt_name;
 753         const struct btf_type *tgt_type;
 754 };
 755
 756 #define BPF_DISPATCHER_MAX 48 /* Fits in 2048B */
 757
 758 struct bpf_dispatcher_prog {
 759         struct bpf_prog *prog;
 760         refcount_t users;
 761 };
 762
 763 struct bpf_dispatcher {
 764         /* dispatcher mutex */
 765         struct mutex mutex;
 766         void *func;
 767         struct bpf_dispatcher_prog progs[BPF_DISPATCHER_MAX];
 768         int num_progs;
 769         void *image;
 770         u32 image_off;
 771         struct bpf_ksym ksym;
 772 };
 773
 774 static __always_inline __nocfi unsigned int bpf_dispatcher_nop_func(
 775         const void *ctx,
 776         const struct bpf_insn *insnsi,
 777         unsigned int (*bpf_func)(const void *,
 778                                  const struct bpf_insn *))
 779 {
 780         return bpf_func(ctx, insnsi);
 781 }
 782 #ifdef CONFIG_BPF_JIT
 783 int bpf_trampoline_link_prog(struct bpf_prog *prog, struct bpf_trampoline *tr);
 784 int bpf_trampoline_unlink_prog(struct bpf_prog *prog, struct bpf_trampoline *tr);
 785 struct bpf_trampoline *bpf_trampoline_get(u64 key,
 786                                           struct bpf_attach_target_info *tgt_info);
 787 void bpf_trampoline_put(struct bpf_trampoline *tr);
 788 int arch_prepare_bpf_dispatcher(void *image, s64 *funcs, int num_funcs);
 789 #define BPF_DISPATCHER_INIT(_name) {                            \
 790         .mutex = __MUTEX_INITIALIZER(_name.mutex),              \
 791         .func = &_name##_func,                                  \
 792         .progs = {},                                            \
 793         .num_progs = 0,                                         \
 794         .image = NULL,                                          \
 795         .image_off = 0,                                         \
 796         .ksym = {                                               \
 797                 .name  = #_name,                                \
 798                 .lnode = LIST_HEAD_INIT(_name.ksym.lnode),      \
 799         },                                                      \
 800 }
 801
 802 #define DEFINE_BPF_DISPATCHER(name)                                     \
 803         noinline __nocfi unsigned int bpf_dispatcher_##name##_func(     \
 804                 const void *ctx,                                        \
 805                 const struct bpf_insn *insnsi,                          \
 806                 unsigned int (*bpf_func)(const void *,                  \
 807                                          const struct bpf_insn *))      \
 808         {                                                               \
 809                 return bpf_func(ctx, insnsi);                           \
 810         }                                                               \
 811         EXPORT_SYMBOL(bpf_dispatcher_##name##_func);                    \
 812         struct bpf_dispatcher bpf_dispatcher_##name =                   \
 813                 BPF_DISPATCHER_INIT(bpf_dispatcher_##name);
 814 #define DECLARE_BPF_DISPATCHER(name)                                    \
 815         unsigned int bpf_dispatcher_##name##_func(                      \
 816                 const void *ctx,                                        \
 817                 const struct bpf_insn *insnsi,                          \
 818                 unsigned int (*bpf_func)(const void *,                  \
 819                                          const struct bpf_insn *));     \
 820         extern struct bpf_dispatcher bpf_dispatcher_##name;
 821 #define BPF_DISPATCHER_FUNC(name) bpf_dispatcher_##name##_func
 822 #define BPF_DISPATCHER_PTR(name) (&bpf_dispatcher_##name)
 823 void bpf_dispatcher_change_prog(struct bpf_dispatcher *d, struct bpf_prog *from,
 824                                 struct bpf_prog *to);
 825 /* Called only from JIT-enabled code, so there's no need for stubs. */
 826 void *bpf_jit_alloc_exec_page(void);
 827 void bpf_image_ksym_add(void *data, struct bpf_ksym *ksym);
 828 void bpf_image_ksym_del(struct bpf_ksym *ksym);
 829 void bpf_ksym_add(struct bpf_ksym *ksym);
 830 void bpf_ksym_del(struct bpf_ksym *ksym);
 831 int bpf_jit_charge_modmem(u32 pages);
 832 void bpf_jit_uncharge_modmem(u32 pages);
 833 bool bpf_prog_has_trampoline(const struct bpf_prog *prog);
 834 #else
 835 static inline int bpf_trampoline_link_prog(struct bpf_prog *prog,
 836                                            struct bpf_trampoline *tr)
 837 {
 838         return -ENOTSUPP;
 839 }
 840 static inline int bpf_trampoline_unlink_prog(struct bpf_prog *prog,
 841                                              struct bpf_trampoline *tr)
 842 {
 843         return -ENOTSUPP;
 844 }
 845 static inline struct bpf_trampoline *bpf_trampoline_get(u64 key,
 846                                                         struct bpf_attach_target_info *tgt_info)
 847 {
 848         return ERR_PTR(-EOPNOTSUPP);
 849 }
 850 static inline void bpf_trampoline_put(struct bpf_trampoline *tr) {}
 851 #define DEFINE_BPF_DISPATCHER(name)
 852 #define DECLARE_BPF_DISPATCHER(name)
 853 #define BPF_DISPATCHER_FUNC(name) bpf_dispatcher_nop_func
 854 #define BPF_DISPATCHER_PTR(name) NULL
 855 static inline void bpf_dispatcher_change_prog(struct bpf_dispatcher *d,
 856                                               struct bpf_prog *from,
 857                                               struct bpf_prog *to) {}
 858 static inline bool is_bpf_image_address(unsigned long address)
 859 {
 860         return false;
 861 }
 862 static inline bool bpf_prog_has_trampoline(const struct bpf_prog *prog)
 863 {
 864         return false;
 865 }
 866 #endif
 867
 868 struct bpf_func_info_aux {
 869         u16 linkage;
 870         bool unreliable;
 871 };
 872
 873 enum bpf_jit_poke_reason {
 874         BPF_POKE_REASON_TAIL_CALL,
 875 };
 876
 877 /* Descriptor of pokes pointing /into/ the JITed image. */
 878 struct bpf_jit_poke_descriptor {
 879         void *tailcall_target;
 880         void *tailcall_bypass;
 881         void *bypass_addr;
 882         void *aux;
 883         union {
 884                 struct {
 885                         struct bpf_map *map;
 886                         u32 key;
 887                 } tail_call;
 888         };
 889         bool tailcall_target_stable;
 890         u8 adj_off;
 891         u16 reason;
 892         u32 insn_idx;
 893 };
 894
 895 /* reg_type info for ctx arguments */
 896 struct bpf_ctx_arg_aux {
 897         u32 offset;
 898         enum bpf_reg_type reg_type;
 899         u32 btf_id;
 900 };
 901
 902 struct btf_mod_pair {
 903         struct btf *btf;
 904         struct module *module;
 905 };
 906
 907 struct bpf_kfunc_desc_tab;
 908
 909 struct bpf_prog_aux {
 910         atomic64_t refcnt;
 911         u32 used_map_cnt;
 912         u32 used_btf_cnt;
 913         u32 max_ctx_offset;
 914         u32 max_pkt_offset;
 915         u32 max_tp_access;
 916         u32 stack_depth;
 917         u32 id;
 918         u32 func_cnt; /* used by non-func prog as the number of func progs */
 919         u32 func_idx; /* 0 for non-func prog, the index in func array for func prog */
 920         u32 attach_btf_id; /* in-kernel BTF type id to attach to */
 921         u32 ctx_arg_info_size;
 922         u32 max_rdonly_access;
 923         u32 max_rdwr_access;
 924         struct btf *attach_btf;
 925         const struct bpf_ctx_arg_aux *ctx_arg_info;
 926         struct mutex dst_mutex; /* protects dst_* pointers below, *after* prog becomes visible */
 927         struct bpf_prog *dst_prog;
 928         struct bpf_trampoline *dst_trampoline;
 929         enum bpf_prog_type saved_dst_prog_type;
 930         enum bpf_attach_type saved_dst_attach_type;
 931         bool verifier_zext; /* Zero extensions has been inserted by verifier. */
 932         bool offload_requested;
 933         bool attach_btf_trace; /* true if attaching to BTF-enabled raw tp */
 934         bool func_proto_unreliable;
 935         bool sleepable;
 936         bool tail_call_reachable;
 937         struct hlist_node tramp_hlist;
 938         /* BTF_KIND_FUNC_PROTO for valid attach_btf_id */
 939         const struct btf_type *attach_func_proto;
 940         /* function name for valid attach_btf_id */
 941         const char *attach_func_name;
 942         struct bpf_prog **func;
 943         void *jit_data; /* JIT specific data. arch dependent */
 944         struct bpf_jit_poke_descriptor *poke_tab;
 945         struct bpf_kfunc_desc_tab *kfunc_tab;
 946         struct bpf_kfunc_btf_tab *kfunc_btf_tab;
 947         u32 size_poke_tab;
 948         struct bpf_ksym ksym;
 949         const struct bpf_prog_ops *ops;
 950         struct bpf_map **used_maps;
 951         struct mutex used_maps_mutex; /* mutex for used_maps and used_map_cnt */
 952         struct btf_mod_pair *used_btfs;
 953         struct bpf_prog *prog;
 954         struct user_struct *user;
 955         u64 load_time; /* ns since boottime */
 956         u32 verified_insns;
 957         struct bpf_map *cgroup_storage[MAX_BPF_CGROUP_STORAGE_TYPE];
 958         char name[BPF_OBJ_NAME_LEN];
 959 #ifdef CONFIG_SECURITY
 960         void *security;
 961 #endif
 962         struct bpf_prog_offload *offload;
 963         struct btf *btf;
 964         struct bpf_func_info *func_info;
 965         struct bpf_func_info_aux *func_info_aux;
 966         /* bpf_line_info loaded from userspace.  linfo->insn_off
 967          * has the xlated insn offset.
 968          * Both the main and sub prog share the same linfo.
 969          * The subprog can access its first linfo by
 970          * using the linfo_idx.
 971          */
 972         struct bpf_line_info *linfo;
 973         /* jited_linfo is the jited addr of the linfo.  It has a
 974          * one to one mapping to linfo:
 975          * jited_linfo[i] is the jited addr for the linfo[i]->insn_off.
 976          * Both the main and sub prog share the same jited_linfo.
 977          * The subprog can access its first jited_linfo by
 978          * using the linfo_idx.
 979          */
 980         void **jited_linfo;
 981         u32 func_info_cnt;
 982         u32 nr_linfo;
 983         /* subprog can use linfo_idx to access its first linfo and
 984          * jited_linfo.
 985          * main prog always has linfo_idx == 0
 986          */
 987         u32 linfo_idx;
 988         u32 num_exentries;
 989         struct exception_table_entry *extable;
 990         union {
 991                 struct work_struct work;
 992                 struct rcu_head rcu;
 993         };
 994 };
 995
 996 struct bpf_array_aux {
 997         /* 'Ownership' of prog array is claimed by the first program that
 998          * is going to use this map or by the first program which FD is
 999          * stored in the map to make sure that all callers and callees have
1000          * the same prog type and JITed flag.
1001          */
1002         struct {
1003                 spinlock_t lock;
1004                 enum bpf_prog_type type;
1005                 bool jited;
1006         } owner;
1007         /* Programs with direct jumps into programs part of this array. */
1008         struct list_head poke_progs;
1009         struct bpf_map *map;
1010         struct mutex poke_mutex;
1011         struct work_struct work;
1012 };
1013
1014 struct bpf_link {
1015         atomic64_t refcnt;
1016         u32 id;
1017         enum bpf_link_type type;
1018         const struct bpf_link_ops *ops;
1019         struct bpf_prog *prog;
1020         struct work_struct work;
1021 };
1022
1023 struct bpf_link_ops {
1024         void (*release)(struct bpf_link *link);
1025         void (*dealloc)(struct bpf_link *link);
1026         int (*detach)(struct bpf_link *link);
1027         int (*update_prog)(struct bpf_link *link, struct bpf_prog *new_prog,
1028                            struct bpf_prog *old_prog);
1029         void (*show_fdinfo)(const struct bpf_link *link, struct seq_file *seq);
1030         int (*fill_link_info)(const struct bpf_link *link,
1031                               struct bpf_link_info *info);
1032 };
1033
1034 struct bpf_link_primer {
1035         struct bpf_link *link;
1036         struct file *file;
1037         int fd;
1038         u32 id;
1039 };
1040
1041 struct bpf_struct_ops_value;
1042 struct btf_member;
1043
1044 #define BPF_STRUCT_OPS_MAX_NR_MEMBERS 64
1045 struct bpf_struct_ops {
1046         const struct bpf_verifier_ops *verifier_ops;
1047         int (*init)(struct btf *btf);
1048         int (*check_member)(const struct btf_type *t,
1049                             const struct btf_member *member);
1050         int (*init_member)(const struct btf_type *t,
1051                            const struct btf_member *member,
1052                            void *kdata, const void *udata);
1053         int (*reg)(void *kdata);
1054         void (*unreg)(void *kdata);
1055         const struct btf_type *type;
1056         const struct btf_type *value_type;
1057         const char *name;
1058         struct btf_func_model func_models[BPF_STRUCT_OPS_MAX_NR_MEMBERS];
1059         u32 type_id;
1060         u32 value_id;
1061 };
1062
1063 #if defined(CONFIG_BPF_JIT) && defined(CONFIG_BPF_SYSCALL)
1064 #define BPF_MODULE_OWNER ((void *)((0xeB9FUL << 2) + POISON_POINTER_DELTA))
1065 const struct bpf_struct_ops *bpf_struct_ops_find(u32 type_id);
1066 void bpf_struct_ops_init(struct btf *btf, struct bpf_verifier_log *log);
1067 bool bpf_struct_ops_get(const void *kdata);
1068 void bpf_struct_ops_put(const void *kdata);
1069 int bpf_struct_ops_map_sys_lookup_elem(struct bpf_map *map, void *key,
1070                                        void *value);
1071 int bpf_struct_ops_prepare_trampoline(struct bpf_tramp_progs *tprogs,
1072                                       struct bpf_prog *prog,
1073                                       const struct btf_func_model *model,
1074                                       void *image, void *image_end);
1075 static inline bool bpf_try_module_get(const void *data, struct module *owner)
1076 {
1077         if (owner == BPF_MODULE_OWNER)
1078                 return bpf_struct_ops_get(data);
1079         else
1080                 return try_module_get(owner);
1081 }
1082 static inline void bpf_module_put(const void *data, struct module *owner)
1083 {
1084         if (owner == BPF_MODULE_OWNER)
1085                 bpf_struct_ops_put(data);
1086         else
1087                 module_put(owner);
1088 }
1089
1090 #ifdef CONFIG_NET
1091 /* Define it here to avoid the use of forward declaration */
1092 struct bpf_dummy_ops_state {
1093         int val;
1094 };
1095
1096 struct bpf_dummy_ops {
1097         int (*test_1)(struct bpf_dummy_ops_state *cb);
1098         int (*test_2)(struct bpf_dummy_ops_state *cb, int a1, unsigned short a2,
1099                       char a3, unsigned long a4);
1100 };
1101
1102 int bpf_struct_ops_test_run(struct bpf_prog *prog, const union bpf_attr *kattr,
1103                             union bpf_attr __user *uattr);
1104 #endif
1105 #else
1106 static inline const struct bpf_struct_ops *bpf_struct_ops_find(u32 type_id)
1107 {
1108         return NULL;
1109 }
1110 static inline void bpf_struct_ops_init(struct btf *btf,
1111                                        struct bpf_verifier_log *log)
1112 {
1113 }
1114 static inline bool bpf_try_module_get(const void *data, struct module *owner)
1115 {
1116         return try_module_get(owner);
1117 }
1118 static inline void bpf_module_put(const void *data, struct module *owner)
1119 {
1120         module_put(owner);
1121 }
1122 static inline int bpf_struct_ops_map_sys_lookup_elem(struct bpf_map *map,
1123                                                      void *key,
1124                                                      void *value)
1125 {
1126         return -EINVAL;
1127 }
1128 #endif
1129
1130 struct bpf_array {
1131         struct bpf_map map;
1132         u32 elem_size;
1133         u32 index_mask;
1134         struct bpf_array_aux *aux;
1135         union {
1136                 char value[0] __aligned(8);
1137                 void *ptrs[0] __aligned(8);
1138                 void __percpu *pptrs[0] __aligned(8);
1139         };
1140 };
1141
1142 #define BPF_COMPLEXITY_LIMIT_INSNS      1000000 /* yes. 1M insns */
1143 #define MAX_TAIL_CALL_CNT 33
1144
1145 #define BPF_F_ACCESS_MASK       (BPF_F_RDONLY |         \
1146                                  BPF_F_RDONLY_PROG |    \
1147                                  BPF_F_WRONLY |         \
1148                                  BPF_F_WRONLY_PROG)
1149
1150 #define BPF_MAP_CAN_READ        BIT(0)
1151 #define BPF_MAP_CAN_WRITE       BIT(1)
1152
1153 static inline u32 bpf_map_flags_to_cap(struct bpf_map *map)
1154 {
1155         u32 access_flags = map->map_flags & (BPF_F_RDONLY_PROG | BPF_F_WRONLY_PROG);
1156
1157         /* Combination of BPF_F_RDONLY_PROG | BPF_F_WRONLY_PROG is
1158          * not possible.
1159          */
1160         if (access_flags & BPF_F_RDONLY_PROG)
1161                 return BPF_MAP_CAN_READ;
1162         else if (access_flags & BPF_F_WRONLY_PROG)
1163                 return BPF_MAP_CAN_WRITE;
1164         else
1165                 return BPF_MAP_CAN_READ | BPF_MAP_CAN_WRITE;
1166 }
1167
1168 static inline bool bpf_map_flags_access_ok(u32 access_flags)
1169 {
1170         return (access_flags & (BPF_F_RDONLY_PROG | BPF_F_WRONLY_PROG)) !=
1171                (BPF_F_RDONLY_PROG | BPF_F_WRONLY_PROG);
1172 }
1173
1174 struct bpf_event_entry {
1175         struct perf_event *event;
1176         struct file *perf_file;
1177         struct file *map_file;
1178         struct rcu_head rcu;
1179 };
1180
1181 bool bpf_prog_array_compatible(struct bpf_array *array, const struct bpf_prog *fp);
1182 int bpf_prog_calc_tag(struct bpf_prog *fp);
1183
1184 const struct bpf_func_proto *bpf_get_trace_printk_proto(void);
1185 const struct bpf_func_proto *bpf_get_trace_vprintk_proto(void);
1186
1187 typedef unsigned long (*bpf_ctx_copy_t)(void *dst, const void *src,
1188                                         unsigned long off, unsigned long len);
1189 typedef u32 (*bpf_convert_ctx_access_t)(enum bpf_access_type type,
1190                                         const struct bpf_insn *src,
1191                                         struct bpf_insn *dst,
1192                                         struct bpf_prog *prog,
1193                                         u32 *target_size);
1194
1195 u64 bpf_event_output(struct bpf_map *map, u64 flags, void *meta, u64 meta_size,
1196                      void *ctx, u64 ctx_size, bpf_ctx_copy_t ctx_copy);
1197
1198 /* an array of programs to be executed under rcu_lock.
1199  *
1200  * Typical usage:
1201  * ret = BPF_PROG_RUN_ARRAY(&bpf_prog_array, ctx, bpf_prog_run);
1202  *
1203  * the structure returned by bpf_prog_array_alloc() should be populated
1204  * with program pointers and the last pointer must be NULL.
1205  * The user has to keep refcnt on the program and make sure the program
1206  * is removed from the array before bpf_prog_put().
1207  * The 'struct bpf_prog_array *' should only be replaced with xchg()
1208  * since other cpus are walking the array of pointers in parallel.
1209  */
1210 struct bpf_prog_array_item {
1211         struct bpf_prog *prog;
1212         union {
1213                 struct bpf_cgroup_storage *cgroup_storage[MAX_BPF_CGROUP_STORAGE_TYPE];
1214                 u64 bpf_cookie;
1215         };
1216 };
1217
1218 struct bpf_prog_array {
1219         struct rcu_head rcu;
1220         struct bpf_prog_array_item items[];
1221 };
1222
1223 struct bpf_prog_array *bpf_prog_array_alloc(u32 prog_cnt, gfp_t flags);
1224 void bpf_prog_array_free(struct bpf_prog_array *progs);
1225 int bpf_prog_array_length(struct bpf_prog_array *progs);
1226 bool bpf_prog_array_is_empty(struct bpf_prog_array *array);
1227 int bpf_prog_array_copy_to_user(struct bpf_prog_array *progs,
1228                                 __u32 __user *prog_ids, u32 cnt);
1229
1230 void bpf_prog_array_delete_safe(struct bpf_prog_array *progs,
1231                                 struct bpf_prog *old_prog);
1232 int bpf_prog_array_delete_safe_at(struct bpf_prog_array *array, int index);
1233 int bpf_prog_array_update_at(struct bpf_prog_array *array, int index,
1234                              struct bpf_prog *prog);
1235 int bpf_prog_array_copy_info(struct bpf_prog_array *array,
1236                              u32 *prog_ids, u32 request_cnt,
1237                              u32 *prog_cnt);
1238 int bpf_prog_array_copy(struct bpf_prog_array *old_array,
1239                         struct bpf_prog *exclude_prog,
1240                         struct bpf_prog *include_prog,
1241                         u64 bpf_cookie,
1242                         struct bpf_prog_array **new_array);
1243
1244 struct bpf_run_ctx {};
1245
1246 struct bpf_cg_run_ctx {
1247         struct bpf_run_ctx run_ctx;
1248         const struct bpf_prog_array_item *prog_item;
1249 };
1250
1251 struct bpf_trace_run_ctx {
1252         struct bpf_run_ctx run_ctx;
1253         u64 bpf_cookie;
1254 };
1255
1256 static inline struct bpf_run_ctx *bpf_set_run_ctx(struct bpf_run_ctx *new_ctx)
1257 {
1258         struct bpf_run_ctx *old_ctx = NULL;
1259
1260 #ifdef CONFIG_BPF_SYSCALL
1261         old_ctx = current->bpf_ctx;
1262         current->bpf_ctx = new_ctx;
1263 #endif
1264         return old_ctx;
1265 }
1266
1267 static inline void bpf_reset_run_ctx(struct bpf_run_ctx *old_ctx)
1268 {
1269 #ifdef CONFIG_BPF_SYSCALL
1270         current->bpf_ctx = old_ctx;
1271 #endif
1272 }
1273
1274 /* BPF program asks to bypass CAP_NET_BIND_SERVICE in bind. */
1275 #define BPF_RET_BIND_NO_CAP_NET_BIND_SERVICE                    (1 << 0)
1276 /* BPF program asks to set CN on the packet. */
1277 #define BPF_RET_SET_CN                                          (1 << 0)
1278
1279 typedef u32 (*bpf_prog_run_fn)(const struct bpf_prog *prog, const void *ctx);
1280
1281 static __always_inline u32
1282 BPF_PROG_RUN_ARRAY_CG_FLAGS(const struct bpf_prog_array __rcu *array_rcu,
1283                             const void *ctx, bpf_prog_run_fn run_prog,
1284                             u32 *ret_flags)
1285 {
1286         const struct bpf_prog_array_item *item;
1287         const struct bpf_prog *prog;
1288         const struct bpf_prog_array *array;
1289         struct bpf_run_ctx *old_run_ctx;
1290         struct bpf_cg_run_ctx run_ctx;
1291         u32 ret = 1;
1292         u32 func_ret;
1293
1294         migrate_disable();
1295         rcu_read_lock();
1296         array = rcu_dereference(array_rcu);
1297         item = &array->items[0];
1298         old_run_ctx = bpf_set_run_ctx(&run_ctx.run_ctx);
1299         while ((prog = READ_ONCE(item->prog))) {
1300                 run_ctx.prog_item = item;
1301                 func_ret = run_prog(prog, ctx);
1302                 ret &= (func_ret & 1);
1303                 *(ret_flags) |= (func_ret >> 1);
1304                 item++;
1305         }
1306         bpf_reset_run_ctx(old_run_ctx);
1307         rcu_read_unlock();
1308         migrate_enable();
1309         return ret;
1310 }
1311
1312 static __always_inline u32
1313 BPF_PROG_RUN_ARRAY_CG(const struct bpf_prog_array __rcu *array_rcu,
1314                       const void *ctx, bpf_prog_run_fn run_prog)
1315 {
1316         const struct bpf_prog_array_item *item;
1317         const struct bpf_prog *prog;
1318         const struct bpf_prog_array *array;
1319         struct bpf_run_ctx *old_run_ctx;
1320         struct bpf_cg_run_ctx run_ctx;
1321         u32 ret = 1;
1322
1323         migrate_disable();
1324         rcu_read_lock();
1325         array = rcu_dereference(array_rcu);
1326         item = &array->items[0];
1327         old_run_ctx = bpf_set_run_ctx(&run_ctx.run_ctx);
1328         while ((prog = READ_ONCE(item->prog))) {
1329                 run_ctx.prog_item = item;
1330                 ret &= run_prog(prog, ctx);
1331                 item++;
1332         }
1333         bpf_reset_run_ctx(old_run_ctx);
1334         rcu_read_unlock();
1335         migrate_enable();
1336         return ret;
1337 }
1338
1339 static __always_inline u32
1340 BPF_PROG_RUN_ARRAY(const struct bpf_prog_array __rcu *array_rcu,
1341                    const void *ctx, bpf_prog_run_fn run_prog)
1342 {
1343         const struct bpf_prog_array_item *item;
1344         const struct bpf_prog *prog;
1345         const struct bpf_prog_array *array;
1346         struct bpf_run_ctx *old_run_ctx;
1347         struct bpf_trace_run_ctx run_ctx;
1348         u32 ret = 1;
1349
1350         migrate_disable();
1351         rcu_read_lock();
1352         array = rcu_dereference(array_rcu);
1353         if (unlikely(!array))
1354                 goto out;
1355         old_run_ctx = bpf_set_run_ctx(&run_ctx.run_ctx);
1356         item = &array->items[0];
1357         while ((prog = READ_ONCE(item->prog))) {
1358                 run_ctx.bpf_cookie = item->bpf_cookie;
1359                 ret &= run_prog(prog, ctx);
1360                 item++;
1361         }
1362         bpf_reset_run_ctx(old_run_ctx);
1363 out:
1364         rcu_read_unlock();
1365         migrate_enable();
1366         return ret;
1367 }
1368
1369 /* To be used by __cgroup_bpf_run_filter_skb for EGRESS BPF progs
1370  * so BPF programs can request cwr for TCP packets.
1371  *
1372  * Current cgroup skb programs can only return 0 or 1 (0 to drop the
1373  * packet. This macro changes the behavior so the low order bit
1374  * indicates whether the packet should be dropped (0) or not (1)
1375  * and the next bit is a congestion notification bit. This could be
1376  * used by TCP to call tcp_enter_cwr()
1377  *
1378  * Hence, new allowed return values of CGROUP EGRESS BPF programs are:
1379  *   0: drop packet
1380  *   1: keep packet
1381  *   2: drop packet and cn
1382  *   3: keep packet and cn
1383  *
1384  * This macro then converts it to one of the NET_XMIT or an error
1385  * code that is then interpreted as drop packet (and no cn):
1386  *   0: NET_XMIT_SUCCESS  skb should be transmitted
1387  *   1: NET_XMIT_DROP     skb should be dropped and cn
1388  *   2: NET_XMIT_CN       skb should be transmitted and cn
1389  *   3: -EPERM            skb should be dropped
1390  */
1391 #define BPF_PROG_CGROUP_INET_EGRESS_RUN_ARRAY(array, ctx, func)         \
1392         ({                                              \
1393                 u32 _flags = 0;                         \
1394                 bool _cn;                               \
1395                 u32 _ret;                               \
1396                 _ret = BPF_PROG_RUN_ARRAY_CG_FLAGS(array, ctx, func, &_flags); \
1397                 _cn = _flags & BPF_RET_SET_CN;          \
1398                 if (_ret)                               \
1399                         _ret = (_cn ? NET_XMIT_CN : NET_XMIT_SUCCESS);  \
1400                 else                                    \
1401                         _ret = (_cn ? NET_XMIT_DROP : -EPERM);          \
1402                 _ret;                                   \
1403         })
1404
1405 #ifdef CONFIG_BPF_SYSCALL
1406 DECLARE_PER_CPU(int, bpf_prog_active);
1407 extern struct mutex bpf_stats_enabled_mutex;
1408
1409 /*
1410  * Block execution of BPF programs attached to instrumentation (perf,
1411  * kprobes, tracepoints) to prevent deadlocks on map operations as any of
1412  * these events can happen inside a region which holds a map bucket lock
1413  * and can deadlock on it.
1414  */
1415 static inline void bpf_disable_instrumentation(void)
1416 {
1417         migrate_disable();
1418         this_cpu_inc(bpf_prog_active);
1419 }
1420
1421 static inline void bpf_enable_instrumentation(void)
1422 {
1423         this_cpu_dec(bpf_prog_active);
1424         migrate_enable();
1425 }
1426
1427 extern const struct file_operations bpf_map_fops;
1428 extern const struct file_operations bpf_prog_fops;
1429 extern const struct file_operations bpf_iter_fops;
1430
1431 #define BPF_PROG_TYPE(_id, _name, prog_ctx_type, kern_ctx_type) \
1432         extern const struct bpf_prog_ops _name ## _prog_ops; \
1433         extern const struct bpf_verifier_ops _name ## _verifier_ops;
1434 #define BPF_MAP_TYPE(_id, _ops) \
1435         extern const struct bpf_map_ops _ops;
1436 #define BPF_LINK_TYPE(_id, _name)
1437 #include <linux/bpf_types.h>
1438 #undef BPF_PROG_TYPE
1439 #undef BPF_MAP_TYPE
1440 #undef BPF_LINK_TYPE
1441
1442 extern const struct bpf_prog_ops bpf_offload_prog_ops;
1443 extern const struct bpf_verifier_ops tc_cls_act_analyzer_ops;
1444 extern const struct bpf_verifier_ops xdp_analyzer_ops;
1445
1446 struct bpf_prog *bpf_prog_get(u32 ufd);
1447 struct bpf_prog *bpf_prog_get_type_dev(u32 ufd, enum bpf_prog_type type,
1448                                        bool attach_drv);
1449 void bpf_prog_add(struct bpf_prog *prog, int i);
1450 void bpf_prog_sub(struct bpf_prog *prog, int i);
1451 void bpf_prog_inc(struct bpf_prog *prog);
1452 struct bpf_prog * __must_check bpf_prog_inc_not_zero(struct bpf_prog *prog);
1453 void bpf_prog_put(struct bpf_prog *prog);
1454
1455 void bpf_prog_free_id(struct bpf_prog *prog, bool do_idr_lock);
1456 void bpf_map_free_id(struct bpf_map *map, bool do_idr_lock);
1457
1458 struct bpf_map *bpf_map_get(u32 ufd);
1459 struct bpf_map *bpf_map_get_with_uref(u32 ufd);
1460 struct bpf_map *__bpf_map_get(struct fd f);
1461 void bpf_map_inc(struct bpf_map *map);
1462 void bpf_map_inc_with_uref(struct bpf_map *map);
1463 struct bpf_map * __must_check bpf_map_inc_not_zero(struct bpf_map *map);
1464 void bpf_map_put_with_uref(struct bpf_map *map);
1465 void bpf_map_put(struct bpf_map *map);
1466 void *bpf_map_area_alloc(u64 size, int numa_node);
1467 void *bpf_map_area_mmapable_alloc(u64 size, int numa_node);
1468 void bpf_map_area_free(void *base);
1469 bool bpf_map_write_active(const struct bpf_map *map);
1470 void bpf_map_init_from_attr(struct bpf_map *map, union bpf_attr *attr);
1471 int  generic_map_lookup_batch(struct bpf_map *map,
1472                               const union bpf_attr *attr,
1473                               union bpf_attr __user *uattr);
1474 int  generic_map_update_batch(struct bpf_map *map,
1475                               const union bpf_attr *attr,
1476                               union bpf_attr __user *uattr);
1477 int  generic_map_delete_batch(struct bpf_map *map,
1478                               const union bpf_attr *attr,
1479                               union bpf_attr __user *uattr);
1480 struct bpf_map *bpf_map_get_curr_or_next(u32 *id);
1481 struct bpf_prog *bpf_prog_get_curr_or_next(u32 *id);
1482
1483 #ifdef CONFIG_MEMCG_KMEM
1484 void *bpf_map_kmalloc_node(const struct bpf_map *map, size_t size, gfp_t flags,
1485                            int node);
1486 void *bpf_map_kzalloc(const struct bpf_map *map, size_t size, gfp_t flags);
1487 void __percpu *bpf_map_alloc_percpu(const struct bpf_map *map, size_t size,
1488                                     size_t align, gfp_t flags);
1489 #else
1490 static inline void *
1491 bpf_map_kmalloc_node(const struct bpf_map *map, size_t size, gfp_t flags,
1492                      int node)
1493 {
1494         return kmalloc_node(size, flags, node);
1495 }
1496
1497 static inline void *
1498 bpf_map_kzalloc(const struct bpf_map *map, size_t size, gfp_t flags)
1499 {
1500         return kzalloc(size, flags);
1501 }
1502
1503 static inline void __percpu *
1504 bpf_map_alloc_percpu(const struct bpf_map *map, size_t size, size_t align,
1505                      gfp_t flags)
1506 {
1507         return __alloc_percpu_gfp(size, align, flags);
1508 }
1509 #endif
1510
1511 extern int sysctl_unprivileged_bpf_disabled;
1512
1513 static inline bool bpf_allow_ptr_leaks(void)
1514 {
1515         return perfmon_capable();
1516 }
1517
1518 static inline bool bpf_allow_uninit_stack(void)
1519 {
1520         return perfmon_capable();
1521 }
1522
1523 static inline bool bpf_allow_ptr_to_map_access(void)
1524 {
1525         return perfmon_capable();
1526 }
1527
1528 static inline bool bpf_bypass_spec_v1(void)
1529 {
1530         return perfmon_capable();
1531 }
1532
1533 static inline bool bpf_bypass_spec_v4(void)
1534 {
1535         return perfmon_capable();
1536 }
1537
1538 int bpf_map_new_fd(struct bpf_map *map, int flags);
1539 int bpf_prog_new_fd(struct bpf_prog *prog);
1540
1541 void bpf_link_init(struct bpf_link *link, enum bpf_link_type type,
1542                    const struct bpf_link_ops *ops, struct bpf_prog *prog);
1543 int bpf_link_prime(struct bpf_link *link, struct bpf_link_primer *primer);
1544 int bpf_link_settle(struct bpf_link_primer *primer);
1545 void bpf_link_cleanup(struct bpf_link_primer *primer);
1546 void bpf_link_inc(struct bpf_link *link);
1547 void bpf_link_put(struct bpf_link *link);
1548 int bpf_link_new_fd(struct bpf_link *link);
1549 struct file *bpf_link_new_file(struct bpf_link *link, int *reserved_fd);
1550 struct bpf_link *bpf_link_get_from_fd(u32 ufd);
1551
1552 int bpf_obj_pin_user(u32 ufd, const char __user *pathname);
1553 int bpf_obj_get_user(const char __user *pathname, int flags);
1554
1555 #define BPF_ITER_FUNC_PREFIX "bpf_iter_"
1556 #define DEFINE_BPF_ITER_FUNC(target, args...)                   \
1557         extern int bpf_iter_ ## target(args);                   \
1558         int __init bpf_iter_ ## target(args) { return 0; }
1559
1560 struct bpf_iter_aux_info {
1561         struct bpf_map *map;
1562 };
1563
1564 typedef int (*bpf_iter_attach_target_t)(struct bpf_prog *prog,
1565                                         union bpf_iter_link_info *linfo,
1566                                         struct bpf_iter_aux_info *aux);
1567 typedef void (*bpf_iter_detach_target_t)(struct bpf_iter_aux_info *aux);
1568 typedef void (*bpf_iter_show_fdinfo_t) (const struct bpf_iter_aux_info *aux,
1569                                         struct seq_file *seq);
1570 typedef int (*bpf_iter_fill_link_info_t)(const struct bpf_iter_aux_info *aux,
1571                                          struct bpf_link_info *info);
1572 typedef const struct bpf_func_proto *
1573 (*bpf_iter_get_func_proto_t)(enum bpf_func_id func_id,
1574                              const struct bpf_prog *prog);
1575
1576 enum bpf_iter_feature {
1577         BPF_ITER_RESCHED        = BIT(0),
1578 };
1579
1580 #define BPF_ITER_CTX_ARG_MAX 2
1581 struct bpf_iter_reg {
1582         const char *target;
1583         bpf_iter_attach_target_t attach_target;
1584         bpf_iter_detach_target_t detach_target;
1585         bpf_iter_show_fdinfo_t show_fdinfo;
1586         bpf_iter_fill_link_info_t fill_link_info;
1587         bpf_iter_get_func_proto_t get_func_proto;
1588         u32 ctx_arg_info_size;
1589         u32 feature;
1590         struct bpf_ctx_arg_aux ctx_arg_info[BPF_ITER_CTX_ARG_MAX];
1591         const struct bpf_iter_seq_info *seq_info;
1592 };
1593
1594 struct bpf_iter_meta {
1595         __bpf_md_ptr(struct seq_file *, seq);
1596         u64 session_id;
1597         u64 seq_num;
1598 };
1599
1600 struct bpf_iter__bpf_map_elem {
1601         __bpf_md_ptr(struct bpf_iter_meta *, meta);
1602         __bpf_md_ptr(struct bpf_map *, map);
1603         __bpf_md_ptr(void *, key);
1604         __bpf_md_ptr(void *, value);
1605 };
1606
1607 int bpf_iter_reg_target(const struct bpf_iter_reg *reg_info);
1608 void bpf_iter_unreg_target(const struct bpf_iter_reg *reg_info);
1609 bool bpf_iter_prog_supported(struct bpf_prog *prog);
1610 const struct bpf_func_proto *
1611 bpf_iter_get_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog);
1612 int bpf_iter_link_attach(const union bpf_attr *attr, bpfptr_t uattr, struct bpf_prog *prog);
1613 int bpf_iter_new_fd(struct bpf_link *link);
1614 bool bpf_link_is_iter(struct bpf_link *link);
1615 struct bpf_prog *bpf_iter_get_info(struct bpf_iter_meta *meta, bool in_stop);
1616 int bpf_iter_run_prog(struct bpf_prog *prog, void *ctx);
1617 void bpf_iter_map_show_fdinfo(const struct bpf_iter_aux_info *aux,
1618                               struct seq_file *seq);
1619 int bpf_iter_map_fill_link_info(const struct bpf_iter_aux_info *aux,
1620                                 struct bpf_link_info *info);
1621
1622 int map_set_for_each_callback_args(struct bpf_verifier_env *env,
1623                                    struct bpf_func_state *caller,
1624                                    struct bpf_func_state *callee);
1625
1626 int bpf_percpu_hash_copy(struct bpf_map *map, void *key, void *value);
1627 int bpf_percpu_array_copy(struct bpf_map *map, void *key, void *value);
1628 int bpf_percpu_hash_update(struct bpf_map *map, void *key, void *value,
1629                            u64 flags);
1630 int bpf_percpu_array_update(struct bpf_map *map, void *key, void *value,
1631                             u64 flags);
1632
1633 int bpf_stackmap_copy(struct bpf_map *map, void *key, void *value);
1634
1635 int bpf_fd_array_map_update_elem(struct bpf_map *map, struct file *map_file,
1636                                  void *key, void *value, u64 map_flags);
1637 int bpf_fd_array_map_lookup_elem(struct bpf_map *map, void *key, u32 *value);
1638 int bpf_fd_htab_map_update_elem(struct bpf_map *map, struct file *map_file,
1639                                 void *key, void *value, u64 map_flags);
1640 int bpf_fd_htab_map_lookup_elem(struct bpf_map *map, void *key, u32 *value);
1641
1642 int bpf_get_file_flag(int flags);
1643 int bpf_check_uarg_tail_zero(bpfptr_t uaddr, size_t expected_size,
1644                              size_t actual_size);
1645
1646 /* memcpy that is used with 8-byte aligned pointers, power-of-8 size and
1647  * forced to use 'long' read/writes to try to atomically copy long counters.
1648  * Best-effort only.  No barriers here, since it _will_ race with concurrent
1649  * updates from BPF programs. Called from bpf syscall and mostly used with
1650  * size 8 or 16 bytes, so ask compiler to inline it.
1651  */
1652 static inline void bpf_long_memcpy(void *dst, const void *src, u32 size)
1653 {
1654         const long *lsrc = src;
1655         long *ldst = dst;
1656
1657         size /= sizeof(long);
1658         while (size--)
1659                 *ldst++ = *lsrc++;
1660 }
1661
1662 /* verify correctness of eBPF program */
1663 int bpf_check(struct bpf_prog **fp, union bpf_attr *attr, bpfptr_t uattr);
1664
1665 #ifndef CONFIG_BPF_JIT_ALWAYS_ON
1666 void bpf_patch_call_args(struct bpf_insn *insn, u32 stack_depth);
1667 #endif
1668
1669 struct btf *bpf_get_btf_vmlinux(void);
1670
1671 /* Map specifics */
1672 struct xdp_frame;
1673 struct sk_buff;
1674 struct bpf_dtab_netdev;
1675 struct bpf_cpu_map_entry;
1676
1677 void __dev_flush(void);
1678 int dev_xdp_enqueue(struct net_device *dev, struct xdp_frame *xdpf,
1679                     struct net_device *dev_rx);
1680 int dev_map_enqueue(struct bpf_dtab_netdev *dst, struct xdp_frame *xdpf,
1681                     struct net_device *dev_rx);
1682 int dev_map_enqueue_multi(struct xdp_frame *xdpf, struct net_device *dev_rx,
1683                           struct bpf_map *map, bool exclude_ingress);
1684 int dev_map_generic_redirect(struct bpf_dtab_netdev *dst, struct sk_buff *skb,
1685                              struct bpf_prog *xdp_prog);
1686 int dev_map_redirect_multi(struct net_device *dev, struct sk_buff *skb,
1687                            struct bpf_prog *xdp_prog, struct bpf_map *map,
1688                            bool exclude_ingress);
1689
1690 void __cpu_map_flush(void);
1691 int cpu_map_enqueue(struct bpf_cpu_map_entry *rcpu, struct xdp_frame *xdpf,
1692                     struct net_device *dev_rx);
1693 int cpu_map_generic_redirect(struct bpf_cpu_map_entry *rcpu,
1694                              struct sk_buff *skb);
1695
1696 /* Return map's numa specified by userspace */
1697 static inline int bpf_map_attr_numa_node(const union bpf_attr *attr)
1698 {
1699         return (attr->map_flags & BPF_F_NUMA_NODE) ?
1700                 attr->numa_node : NUMA_NO_NODE;
1701 }
1702
1703 struct bpf_prog *bpf_prog_get_type_path(const char *name, enum bpf_prog_type type);
1704 int array_map_alloc_check(union bpf_attr *attr);
1705
1706 int bpf_prog_test_run_xdp(struct bpf_prog *prog, const union bpf_attr *kattr,
1707                           union bpf_attr __user *uattr);
1708 int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr,
1709                           union bpf_attr __user *uattr);
1710 int bpf_prog_test_run_tracing(struct bpf_prog *prog,
1711                               const union bpf_attr *kattr,
1712                               union bpf_attr __user *uattr);
1713 int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog,
1714                                      const union bpf_attr *kattr,
1715                                      union bpf_attr __user *uattr);
1716 int bpf_prog_test_run_raw_tp(struct bpf_prog *prog,
1717                              const union bpf_attr *kattr,
1718                              union bpf_attr __user *uattr);
1719 int bpf_prog_test_run_sk_lookup(struct bpf_prog *prog,
1720                                 const union bpf_attr *kattr,
1721                                 union bpf_attr __user *uattr);
1722 bool bpf_prog_test_check_kfunc_call(u32 kfunc_id, struct module *owner);
1723 bool btf_ctx_access(int off, int size, enum bpf_access_type type,
1724                     const struct bpf_prog *prog,
1725                     struct bpf_insn_access_aux *info);
1726
1727 static inline bool bpf_tracing_ctx_access(int off, int size,
1728                                           enum bpf_access_type type)
1729 {
1730         if (off < 0 || off >= sizeof(__u64) * MAX_BPF_FUNC_ARGS)
1731                 return false;
1732         if (type != BPF_READ)
1733                 return false;
1734         if (off % size != 0)
1735                 return false;
1736         return true;
1737 }
1738
1739 static inline bool bpf_tracing_btf_ctx_access(int off, int size,
1740                                               enum bpf_access_type type,
1741                                               const struct bpf_prog *prog,
1742                                               struct bpf_insn_access_aux *info)
1743 {
1744         if (!bpf_tracing_ctx_access(off, size, type))
1745                 return false;
1746         return btf_ctx_access(off, size, type, prog, info);
1747 }
1748
1749 int btf_struct_access(struct bpf_verifier_log *log, const struct btf *btf,
1750                       const struct btf_type *t, int off, int size,
1751                       enum bpf_access_type atype,
1752                       u32 *next_btf_id);
1753 bool btf_struct_ids_match(struct bpf_verifier_log *log,
1754                           const struct btf *btf, u32 id, int off,
1755                           const struct btf *need_btf, u32 need_type_id);
1756
1757 int btf_distill_func_proto(struct bpf_verifier_log *log,
1758                            struct btf *btf,
1759                            const struct btf_type *func_proto,
1760                            const char *func_name,
1761                            struct btf_func_model *m);
1762
1763 struct bpf_reg_state;
1764 int btf_check_subprog_arg_match(struct bpf_verifier_env *env, int subprog,
1765                                 struct bpf_reg_state *regs);
1766 int btf_check_kfunc_arg_match(struct bpf_verifier_env *env,
1767                               const struct btf *btf, u32 func_id,
1768                               struct bpf_reg_state *regs);
1769 int btf_prepare_func_args(struct bpf_verifier_env *env, int subprog,
1770                           struct bpf_reg_state *reg);
1771 int btf_check_type_match(struct bpf_verifier_log *log, const struct bpf_prog *prog,
1772                          struct btf *btf, const struct btf_type *t);
1773
1774 struct bpf_prog *bpf_prog_by_id(u32 id);
1775 struct bpf_link *bpf_link_by_id(u32 id);
1776
1777 const struct bpf_func_proto *bpf_base_func_proto(enum bpf_func_id func_id);
1778 void bpf_task_storage_free(struct task_struct *task);
1779 bool bpf_prog_has_kfunc_call(const struct bpf_prog *prog);
1780 const struct btf_func_model *
1781 bpf_jit_find_kfunc_model(const struct bpf_prog *prog,
1782                          const struct bpf_insn *insn);
1783 struct bpf_core_ctx {
1784         struct bpf_verifier_log *log;
1785         const struct btf *btf;
1786 };
1787
1788 int bpf_core_apply(struct bpf_core_ctx *ctx, const struct bpf_core_relo *relo,
1789                    int relo_idx, void *insn);
1790
1791 #else /* !CONFIG_BPF_SYSCALL */
1792 static inline struct bpf_prog *bpf_prog_get(u32 ufd)
1793 {
1794         return ERR_PTR(-EOPNOTSUPP);
1795 }
1796
1797 static inline struct bpf_prog *bpf_prog_get_type_dev(u32 ufd,
1798                                                      enum bpf_prog_type type,
1799                                                      bool attach_drv)
1800 {
1801         return ERR_PTR(-EOPNOTSUPP);
1802 }
1803
1804 static inline void bpf_prog_add(struct bpf_prog *prog, int i)
1805 {
1806 }
1807
1808 static inline void bpf_prog_sub(struct bpf_prog *prog, int i)
1809 {
1810 }
1811
1812 static inline void bpf_prog_put(struct bpf_prog *prog)
1813 {
1814 }
1815
1816 static inline void bpf_prog_inc(struct bpf_prog *prog)
1817 {
1818 }
1819
1820 static inline struct bpf_prog *__must_check
1821 bpf_prog_inc_not_zero(struct bpf_prog *prog)
1822 {
1823         return ERR_PTR(-EOPNOTSUPP);
1824 }
1825
1826 static inline void bpf_link_init(struct bpf_link *link, enum bpf_link_type type,
1827                                  const struct bpf_link_ops *ops,
1828                                  struct bpf_prog *prog)
1829 {
1830 }
1831
1832 static inline int bpf_link_prime(struct bpf_link *link,
1833                                  struct bpf_link_primer *primer)
1834 {
1835         return -EOPNOTSUPP;
1836 }
1837
1838 static inline int bpf_link_settle(struct bpf_link_primer *primer)
1839 {
1840         return -EOPNOTSUPP;
1841 }
1842
1843 static inline void bpf_link_cleanup(struct bpf_link_primer *primer)
1844 {
1845 }
1846
1847 static inline void bpf_link_inc(struct bpf_link *link)
1848 {
1849 }
1850
1851 static inline void bpf_link_put(struct bpf_link *link)
1852 {
1853 }
1854
1855 static inline int bpf_obj_get_user(const char __user *pathname, int flags)
1856 {
1857         return -EOPNOTSUPP;
1858 }
1859
1860 static inline bool dev_map_can_have_prog(struct bpf_map *map)
1861 {
1862         return false;
1863 }
1864
1865 static inline void __dev_flush(void)
1866 {
1867 }
1868
1869 struct xdp_frame;
1870 struct bpf_dtab_netdev;
1871 struct bpf_cpu_map_entry;
1872
1873 static inline
1874 int dev_xdp_enqueue(struct net_device *dev, struct xdp_frame *xdpf,
1875                     struct net_device *dev_rx)
1876 {
1877         return 0;
1878 }
1879
1880 static inline
1881 int dev_map_enqueue(struct bpf_dtab_netdev *dst, struct xdp_frame *xdpf,
1882                     struct net_device *dev_rx)
1883 {
1884         return 0;
1885 }
1886
1887 static inline
1888 int dev_map_enqueue_multi(struct xdp_frame *xdpf, struct net_device *dev_rx,
1889                           struct bpf_map *map, bool exclude_ingress)
1890 {
1891         return 0;
1892 }
1893
1894 struct sk_buff;
1895
1896 static inline int dev_map_generic_redirect(struct bpf_dtab_netdev *dst,
1897                                            struct sk_buff *skb,
1898                                            struct bpf_prog *xdp_prog)
1899 {
1900         return 0;
1901 }
1902
1903 static inline
1904 int dev_map_redirect_multi(struct net_device *dev, struct sk_buff *skb,
1905                            struct bpf_prog *xdp_prog, struct bpf_map *map,
1906                            bool exclude_ingress)
1907 {
1908         return 0;
1909 }
1910
1911 static inline void __cpu_map_flush(void)
1912 {
1913 }
1914
1915 static inline int cpu_map_enqueue(struct bpf_cpu_map_entry *rcpu,
1916                                   struct xdp_frame *xdpf,
1917                                   struct net_device *dev_rx)
1918 {
1919         return 0;
1920 }
1921
1922 static inline int cpu_map_generic_redirect(struct bpf_cpu_map_entry *rcpu,
1923                                            struct sk_buff *skb)
1924 {
1925         return -EOPNOTSUPP;
1926 }
1927
1928 static inline bool cpu_map_prog_allowed(struct bpf_map *map)
1929 {
1930         return false;
1931 }
1932
1933 static inline struct bpf_prog *bpf_prog_get_type_path(const char *name,
1934                                 enum bpf_prog_type type)
1935 {
1936         return ERR_PTR(-EOPNOTSUPP);
1937 }
1938
1939 static inline int bpf_prog_test_run_xdp(struct bpf_prog *prog,
1940                                         const union bpf_attr *kattr,
1941                                         union bpf_attr __user *uattr)
1942 {
1943         return -ENOTSUPP;
1944 }
1945
1946 static inline int bpf_prog_test_run_skb(struct bpf_prog *prog,
1947                                         const union bpf_attr *kattr,
1948                                         union bpf_attr __user *uattr)
1949 {
1950         return -ENOTSUPP;
1951 }
1952
1953 static inline int bpf_prog_test_run_tracing(struct bpf_prog *prog,
1954                                             const union bpf_attr *kattr,
1955                                             union bpf_attr __user *uattr)
1956 {
1957         return -ENOTSUPP;
1958 }
1959
1960 static inline int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog,
1961                                                    const union bpf_attr *kattr,
1962                                                    union bpf_attr __user *uattr)
1963 {
1964         return -ENOTSUPP;
1965 }
1966
1967 static inline int bpf_prog_test_run_sk_lookup(struct bpf_prog *prog,
1968                                               const union bpf_attr *kattr,
1969                                               union bpf_attr __user *uattr)
1970 {
1971         return -ENOTSUPP;
1972 }
1973
1974 static inline bool bpf_prog_test_check_kfunc_call(u32 kfunc_id,
1975                                                   struct module *owner)
1976 {
1977         return false;
1978 }
1979
1980 static inline void bpf_map_put(struct bpf_map *map)
1981 {
1982 }
1983
1984 static inline struct bpf_prog *bpf_prog_by_id(u32 id)
1985 {
1986         return ERR_PTR(-ENOTSUPP);
1987 }
1988
1989 static inline const struct bpf_func_proto *
1990 bpf_base_func_proto(enum bpf_func_id func_id)
1991 {
1992         return NULL;
1993 }
1994
1995 static inline void bpf_task_storage_free(struct task_struct *task)
1996 {
1997 }
1998
1999 static inline bool bpf_prog_has_kfunc_call(const struct bpf_prog *prog)
2000 {
2001         return false;
2002 }
2003
2004 static inline const struct btf_func_model *
2005 bpf_jit_find_kfunc_model(const struct bpf_prog *prog,
2006                          const struct bpf_insn *insn)
2007 {
2008         return NULL;
2009 }
2010 #endif /* CONFIG_BPF_SYSCALL */
2011
2012 void __bpf_free_used_btfs(struct bpf_prog_aux *aux,
2013                           struct btf_mod_pair *used_btfs, u32 len);
2014
2015 static inline struct bpf_prog *bpf_prog_get_type(u32 ufd,
2016                                                  enum bpf_prog_type type)
2017 {
2018         return bpf_prog_get_type_dev(ufd, type, false);
2019 }
2020
2021 void __bpf_free_used_maps(struct bpf_prog_aux *aux,
2022                           struct bpf_map **used_maps, u32 len);
2023
2024 bool bpf_prog_get_ok(struct bpf_prog *, enum bpf_prog_type *, bool);
2025
2026 int bpf_prog_offload_compile(struct bpf_prog *prog);
2027 void bpf_prog_offload_destroy(struct bpf_prog *prog);
2028 int bpf_prog_offload_info_fill(struct bpf_prog_info *info,
2029                                struct bpf_prog *prog);
2030
2031 int bpf_map_offload_info_fill(struct bpf_map_info *info, struct bpf_map *map);
2032
2033 int bpf_map_offload_lookup_elem(struct bpf_map *map, void *key, void *value);
2034 int bpf_map_offload_update_elem(struct bpf_map *map,
2035                                 void *key, void *value, u64 flags);
2036 int bpf_map_offload_delete_elem(struct bpf_map *map, void *key);
2037 int bpf_map_offload_get_next_key(struct bpf_map *map,
2038                                  void *key, void *next_key);
2039
2040 bool bpf_offload_prog_map_match(struct bpf_prog *prog, struct bpf_map *map);
2041
2042 struct bpf_offload_dev *
2043 bpf_offload_dev_create(const struct bpf_prog_offload_ops *ops, void *priv);
2044 void bpf_offload_dev_destroy(struct bpf_offload_dev *offdev);
2045 void *bpf_offload_dev_priv(struct bpf_offload_dev *offdev);
2046 int bpf_offload_dev_netdev_register(struct bpf_offload_dev *offdev,
2047                                     struct net_device *netdev);
2048 void bpf_offload_dev_netdev_unregister(struct bpf_offload_dev *offdev,
2049                                        struct net_device *netdev);
2050 bool bpf_offload_dev_match(struct bpf_prog *prog, struct net_device *netdev);
2051
2052 #if defined(CONFIG_NET) && defined(CONFIG_BPF_SYSCALL)
2053 int bpf_prog_offload_init(struct bpf_prog *prog, union bpf_attr *attr);
2054
2055 static inline bool bpf_prog_is_dev_bound(const struct bpf_prog_aux *aux)
2056 {
2057         return aux->offload_requested;
2058 }
2059
2060 static inline bool bpf_map_is_dev_bound(struct bpf_map *map)
2061 {
2062         return unlikely(map->ops == &bpf_map_offload_ops);
2063 }
2064
2065 struct bpf_map *bpf_map_offload_map_alloc(union bpf_attr *attr);
2066 void bpf_map_offload_map_free(struct bpf_map *map);
2067 int bpf_prog_test_run_syscall(struct bpf_prog *prog,
2068                               const union bpf_attr *kattr,
2069                               union bpf_attr __user *uattr);
2070
2071 int sock_map_get_from_fd(const union bpf_attr *attr, struct bpf_prog *prog);
2072 int sock_map_prog_detach(const union bpf_attr *attr, enum bpf_prog_type ptype);
2073 int sock_map_update_elem_sys(struct bpf_map *map, void *key, void *value, u64 flags);
2074 void sock_map_unhash(struct sock *sk);
2075 void sock_map_close(struct sock *sk, long timeout);
2076 #else
2077 static inline int bpf_prog_offload_init(struct bpf_prog *prog,
2078                                         union bpf_attr *attr)
2079 {
2080         return -EOPNOTSUPP;
2081 }
2082
2083 static inline bool bpf_prog_is_dev_bound(struct bpf_prog_aux *aux)
2084 {
2085         return false;
2086 }
2087
2088 static inline bool bpf_map_is_dev_bound(struct bpf_map *map)
2089 {
2090         return false;
2091 }
2092
2093 static inline struct bpf_map *bpf_map_offload_map_alloc(union bpf_attr *attr)
2094 {
2095         return ERR_PTR(-EOPNOTSUPP);
2096 }
2097
2098 static inline void bpf_map_offload_map_free(struct bpf_map *map)
2099 {
2100 }
2101
2102 static inline int bpf_prog_test_run_syscall(struct bpf_prog *prog,
2103                                             const union bpf_attr *kattr,
2104                                             union bpf_attr __user *uattr)
2105 {
2106         return -ENOTSUPP;
2107 }
2108
2109 #ifdef CONFIG_BPF_SYSCALL
2110 static inline int sock_map_get_from_fd(const union bpf_attr *attr,
2111                                        struct bpf_prog *prog)
2112 {
2113         return -EINVAL;
2114 }
2115
2116 static inline int sock_map_prog_detach(const union bpf_attr *attr,
2117                                        enum bpf_prog_type ptype)
2118 {
2119         return -EOPNOTSUPP;
2120 }
2121
2122 static inline int sock_map_update_elem_sys(struct bpf_map *map, void *key, void *value,
2123                                            u64 flags)
2124 {
2125         return -EOPNOTSUPP;
2126 }
2127 #endif /* CONFIG_BPF_SYSCALL */
2128 #endif /* CONFIG_NET && CONFIG_BPF_SYSCALL */
2129
2130 #if defined(CONFIG_INET) && defined(CONFIG_BPF_SYSCALL)
2131 void bpf_sk_reuseport_detach(struct sock *sk);
2132 int bpf_fd_reuseport_array_lookup_elem(struct bpf_map *map, void *key,
2133                                        void *value);
2134 int bpf_fd_reuseport_array_update_elem(struct bpf_map *map, void *key,
2135                                        void *value, u64 map_flags);
2136 #else
2137 static inline void bpf_sk_reuseport_detach(struct sock *sk)
2138 {
2139 }
2140
2141 #ifdef CONFIG_BPF_SYSCALL
2142 static inline int bpf_fd_reuseport_array_lookup_elem(struct bpf_map *map,
2143                                                      void *key, void *value)
2144 {
2145         return -EOPNOTSUPP;
2146 }
2147
2148 static inline int bpf_fd_reuseport_array_update_elem(struct bpf_map *map,
2149                                                      void *key, void *value,
2150                                                      u64 map_flags)
2151 {
2152         return -EOPNOTSUPP;
2153 }
2154 #endif /* CONFIG_BPF_SYSCALL */
2155 #endif /* defined(CONFIG_INET) && defined(CONFIG_BPF_SYSCALL) */
2156
2157 /* verifier prototypes for helper functions called from eBPF programs */
2158 extern const struct bpf_func_proto bpf_map_lookup_elem_proto;
2159 extern const struct bpf_func_proto bpf_map_update_elem_proto;
2160 extern const struct bpf_func_proto bpf_map_delete_elem_proto;
2161 extern const struct bpf_func_proto bpf_map_push_elem_proto;
2162 extern const struct bpf_func_proto bpf_map_pop_elem_proto;
2163 extern const struct bpf_func_proto bpf_map_peek_elem_proto;
2164
2165 extern const struct bpf_func_proto bpf_get_prandom_u32_proto;
2166 extern const struct bpf_func_proto bpf_get_smp_processor_id_proto;
2167 extern const struct bpf_func_proto bpf_get_numa_node_id_proto;
2168 extern const struct bpf_func_proto bpf_tail_call_proto;
2169 extern const struct bpf_func_proto bpf_ktime_get_ns_proto;
2170 extern const struct bpf_func_proto bpf_ktime_get_boot_ns_proto;
2171 extern const struct bpf_func_proto bpf_get_current_pid_tgid_proto;
2172 extern const struct bpf_func_proto bpf_get_current_uid_gid_proto;
2173 extern const struct bpf_func_proto bpf_get_current_comm_proto;
2174 extern const struct bpf_func_proto bpf_get_stackid_proto;
2175 extern const struct bpf_func_proto bpf_get_stack_proto;
2176 extern const struct bpf_func_proto bpf_get_task_stack_proto;
2177 extern const struct bpf_func_proto bpf_get_stackid_proto_pe;
2178 extern const struct bpf_func_proto bpf_get_stack_proto_pe;
2179 extern const struct bpf_func_proto bpf_sock_map_update_proto;
2180 extern const struct bpf_func_proto bpf_sock_hash_update_proto;
2181 extern const struct bpf_func_proto bpf_get_current_cgroup_id_proto;
2182 extern const struct bpf_func_proto bpf_get_current_ancestor_cgroup_id_proto;
2183 extern const struct bpf_func_proto bpf_msg_redirect_hash_proto;
2184 extern const struct bpf_func_proto bpf_msg_redirect_map_proto;
2185 extern const struct bpf_func_proto bpf_sk_redirect_hash_proto;
2186 extern const struct bpf_func_proto bpf_sk_redirect_map_proto;
2187 extern const struct bpf_func_proto bpf_spin_lock_proto;
2188 extern const struct bpf_func_proto bpf_spin_unlock_proto;
2189 extern const struct bpf_func_proto bpf_get_local_storage_proto;
2190 extern const struct bpf_func_proto bpf_strtol_proto;
2191 extern const struct bpf_func_proto bpf_strtoul_proto;
2192 extern const struct bpf_func_proto bpf_tcp_sock_proto;
2193 extern const struct bpf_func_proto bpf_jiffies64_proto;
2194 extern const struct bpf_func_proto bpf_get_ns_current_pid_tgid_proto;
2195 extern const struct bpf_func_proto bpf_event_output_data_proto;
2196 extern const struct bpf_func_proto bpf_ringbuf_output_proto;
2197 extern const struct bpf_func_proto bpf_ringbuf_reserve_proto;
2198 extern const struct bpf_func_proto bpf_ringbuf_submit_proto;
2199 extern const struct bpf_func_proto bpf_ringbuf_discard_proto;
2200 extern const struct bpf_func_proto bpf_ringbuf_query_proto;
2201 extern const struct bpf_func_proto bpf_skc_to_tcp6_sock_proto;
2202 extern const struct bpf_func_proto bpf_skc_to_tcp_sock_proto;
2203 extern const struct bpf_func_proto bpf_skc_to_tcp_timewait_sock_proto;
2204 extern const struct bpf_func_proto bpf_skc_to_tcp_request_sock_proto;
2205 extern const struct bpf_func_proto bpf_skc_to_udp6_sock_proto;
2206 extern const struct bpf_func_proto bpf_skc_to_unix_sock_proto;
2207 extern const struct bpf_func_proto bpf_copy_from_user_proto;
2208 extern const struct bpf_func_proto bpf_snprintf_btf_proto;
2209 extern const struct bpf_func_proto bpf_snprintf_proto;
2210 extern const struct bpf_func_proto bpf_per_cpu_ptr_proto;
2211 extern const struct bpf_func_proto bpf_this_cpu_ptr_proto;
2212 extern const struct bpf_func_proto bpf_ktime_get_coarse_ns_proto;
2213 extern const struct bpf_func_proto bpf_sock_from_file_proto;
2214 extern const struct bpf_func_proto bpf_get_socket_ptr_cookie_proto;
2215 extern const struct bpf_func_proto bpf_task_storage_get_proto;
2216 extern const struct bpf_func_proto bpf_task_storage_delete_proto;
2217 extern const struct bpf_func_proto bpf_for_each_map_elem_proto;
2218 extern const struct bpf_func_proto bpf_btf_find_by_name_kind_proto;
2219 extern const struct bpf_func_proto bpf_sk_setsockopt_proto;
2220 extern const struct bpf_func_proto bpf_sk_getsockopt_proto;
2221 extern const struct bpf_func_proto bpf_kallsyms_lookup_name_proto;
2222 extern const struct bpf_func_proto bpf_find_vma_proto;
2223 extern const struct bpf_func_proto bpf_loop_proto;
2224 extern const struct bpf_func_proto bpf_strncmp_proto;
2225
2226 const struct bpf_func_proto *tracing_prog_func_proto(
2227   enum bpf_func_id func_id, const struct bpf_prog *prog);
2228
2229 /* Shared helpers among cBPF and eBPF. */
2230 void bpf_user_rnd_init_once(void);
2231 u64 bpf_user_rnd_u32(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);
2232 u64 bpf_get_raw_cpu_id(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);
2233
2234 #if defined(CONFIG_NET)
2235 bool bpf_sock_common_is_valid_access(int off, int size,
2236                                      enum bpf_access_type type,
2237                                      struct bpf_insn_access_aux *info);
2238 bool bpf_sock_is_valid_access(int off, int size, enum bpf_access_type type,
2239                               struct bpf_insn_access_aux *info);
2240 u32 bpf_sock_convert_ctx_access(enum bpf_access_type type,
2241                                 const struct bpf_insn *si,
2242                                 struct bpf_insn *insn_buf,
2243                                 struct bpf_prog *prog,
2244                                 u32 *target_size);
2245 #else
2246 static inline bool bpf_sock_common_is_valid_access(int off, int size,
2247                                                    enum bpf_access_type type,
2248                                                    struct bpf_insn_access_aux *info)
2249 {
2250         return false;
2251 }
2252 static inline bool bpf_sock_is_valid_access(int off, int size,
2253                                             enum bpf_access_type type,
2254                                             struct bpf_insn_access_aux *info)
2255 {
2256         return false;
2257 }
2258 static inline u32 bpf_sock_convert_ctx_access(enum bpf_access_type type,
2259                                               const struct bpf_insn *si,
2260                                               struct bpf_insn *insn_buf,
2261                                               struct bpf_prog *prog,
2262                                               u32 *target_size)
2263 {
2264         return 0;
2265 }
2266 #endif
2267
2268 #ifdef CONFIG_INET
2269 struct sk_reuseport_kern {
2270         struct sk_buff *skb;
2271         struct sock *sk;
2272         struct sock *selected_sk;
2273         struct sock *migrating_sk;
2274         void *data_end;
2275         u32 hash;
2276         u32 reuseport_id;
2277         bool bind_inany;
2278 };
2279 bool bpf_tcp_sock_is_valid_access(int off, int size, enum bpf_access_type type,
2280                                   struct bpf_insn_access_aux *info);
2281
2282 u32 bpf_tcp_sock_convert_ctx_access(enum bpf_access_type type,
2283                                     const struct bpf_insn *si,
2284                                     struct bpf_insn *insn_buf,
2285                                     struct bpf_prog *prog,
2286                                     u32 *target_size);
2287
2288 bool bpf_xdp_sock_is_valid_access(int off, int size, enum bpf_access_type type,
2289                                   struct bpf_insn_access_aux *info);
2290
2291 u32 bpf_xdp_sock_convert_ctx_access(enum bpf_access_type type,
2292                                     const struct bpf_insn *si,
2293                                     struct bpf_insn *insn_buf,
2294                                     struct bpf_prog *prog,
2295                                     u32 *target_size);
2296 #else
2297 static inline bool bpf_tcp_sock_is_valid_access(int off, int size,
2298                                                 enum bpf_access_type type,
2299                                                 struct bpf_insn_access_aux *info)
2300 {
2301         return false;
2302 }
2303
2304 static inline u32 bpf_tcp_sock_convert_ctx_access(enum bpf_access_type type,
2305                                                   const struct bpf_insn *si,
2306                                                   struct bpf_insn *insn_buf,
2307                                                   struct bpf_prog *prog,
2308                                                   u32 *target_size)
2309 {
2310         return 0;
2311 }
2312 static inline bool bpf_xdp_sock_is_valid_access(int off, int size,
2313                                                 enum bpf_access_type type,
2314                                                 struct bpf_insn_access_aux *info)
2315 {
2316         return false;
2317 }
2318
2319 static inline u32 bpf_xdp_sock_convert_ctx_access(enum bpf_access_type type,
2320                                                   const struct bpf_insn *si,
2321                                                   struct bpf_insn *insn_buf,
2322                                                   struct bpf_prog *prog,
2323                                                   u32 *target_size)
2324 {
2325         return 0;
2326 }
2327 #endif /* CONFIG_INET */
2328
2329 enum bpf_text_poke_type {
2330         BPF_MOD_CALL,
2331         BPF_MOD_JUMP,
2332 };
2333
2334 int bpf_arch_text_poke(void *ip, enum bpf_text_poke_type t,
2335                        void *addr1, void *addr2);
2336
2337 struct btf_id_set;
2338 bool btf_id_set_contains(const struct btf_id_set *set, u32 id);
2339
2340 #define MAX_BPRINTF_VARARGS             12
2341
2342 int bpf_bprintf_prepare(char *fmt, u32 fmt_size, const u64 *raw_args,
2343                         u32 **bin_buf, u32 num_args);
2344 void bpf_bprintf_cleanup(void);
2345
2346 #endif /* _LINUX_BPF_H */