1 /* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com 2 * 3 * This program is free software; you can redistribute it and/or 4 * modify it under the terms of version 2 of the GNU General Public 5 * License as published by the Free Software Foundation. 6 */ 7 #ifndef _LINUX_BPF_H 8 #define _LINUX_BPF_H 1 9 10 #include <uapi/linux/bpf.h> 11 12 #include <linux/workqueue.h> 13 #include <linux/file.h> 14 #include <linux/percpu.h> 15 #include <linux/err.h> 16 #include <linux/rbtree_latch.h> 17 #include <linux/numa.h> 18 #include <linux/wait.h> 19 20 struct perf_event; 21 struct bpf_prog; 22 struct bpf_map; 23 24 /* map is generic key/value storage optionally accesible by eBPF programs */ 25 struct bpf_map_ops { 26 /* funcs callable from userspace (via syscall) */ 27 struct bpf_map *(*map_alloc)(union bpf_attr *attr); 28 void (*map_release)(struct bpf_map *map, struct file *map_file); 29 void (*map_free)(struct bpf_map *map); 30 int (*map_get_next_key)(struct bpf_map *map, void *key, void *next_key); 31 32 /* funcs callable from userspace and from eBPF programs */ 33 void *(*map_lookup_elem)(struct bpf_map *map, void *key); 34 int (*map_update_elem)(struct bpf_map *map, void *key, void *value, u64 flags); 35 int (*map_delete_elem)(struct bpf_map *map, void *key); 36 37 /* funcs called by prog_array and perf_event_array map */ 38 void *(*map_fd_get_ptr)(struct bpf_map *map, struct file *map_file, 39 int fd); 40 void (*map_fd_put_ptr)(void *ptr); 41 u32 (*map_gen_lookup)(struct bpf_map *map, struct bpf_insn *insn_buf); 42 u32 (*map_fd_sys_lookup_elem)(void *ptr); 43 }; 44 45 struct bpf_map { 46 /* 1st cacheline with read-mostly members of which some 47 * are also accessed in fast-path (e.g. ops, max_entries). 48 */ 49 const struct bpf_map_ops *ops ____cacheline_aligned; 50 struct bpf_map *inner_map_meta; 51 #ifdef CONFIG_SECURITY 52 void *security; 53 #endif 54 enum bpf_map_type map_type; 55 u32 key_size; 56 u32 value_size; 57 u32 max_entries; 58 u32 map_flags; 59 u32 pages; 60 u32 id; 61 int numa_node; 62 bool unpriv_array; 63 /* 7 bytes hole */ 64 65 /* 2nd cacheline with misc members to avoid false sharing 66 * particularly with refcounting. 67 */ 68 struct user_struct *user ____cacheline_aligned; 69 atomic_t refcnt; 70 atomic_t usercnt; 71 struct work_struct work; 72 char name[BPF_OBJ_NAME_LEN]; 73 }; 74 75 /* function argument constraints */ 76 enum bpf_arg_type { 77 ARG_DONTCARE = 0, /* unused argument in helper function */ 78 79 /* the following constraints used to prototype 80 * bpf_map_lookup/update/delete_elem() functions 81 */ 82 ARG_CONST_MAP_PTR, /* const argument used as pointer to bpf_map */ 83 ARG_PTR_TO_MAP_KEY, /* pointer to stack used as map key */ 84 ARG_PTR_TO_MAP_VALUE, /* pointer to stack used as map value */ 85 86 /* the following constraints used to prototype bpf_memcmp() and other 87 * functions that access data on eBPF program stack 88 */ 89 ARG_PTR_TO_MEM, /* pointer to valid memory (stack, packet, map value) */ 90 ARG_PTR_TO_MEM_OR_NULL, /* pointer to valid memory or NULL */ 91 ARG_PTR_TO_UNINIT_MEM, /* pointer to memory does not need to be initialized, 92 * helper function must fill all bytes or clear 93 * them in error case. 94 */ 95 96 ARG_CONST_SIZE, /* number of bytes accessed from memory */ 97 ARG_CONST_SIZE_OR_ZERO, /* number of bytes accessed from memory or 0 */ 98 99 ARG_PTR_TO_CTX, /* pointer to context */ 100 ARG_ANYTHING, /* any (initialized) argument is ok */ 101 }; 102 103 /* type of values returned from helper functions */ 104 enum bpf_return_type { 105 RET_INTEGER, /* function returns integer */ 106 RET_VOID, /* function doesn't return anything */ 107 RET_PTR_TO_MAP_VALUE_OR_NULL, /* returns a pointer to map elem value or NULL */ 108 }; 109 110 /* eBPF function prototype used by verifier to allow BPF_CALLs from eBPF programs 111 * to in-kernel helper functions and for adjusting imm32 field in BPF_CALL 112 * instructions after verifying 113 */ 114 struct bpf_func_proto { 115 u64 (*func)(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5); 116 bool gpl_only; 117 bool pkt_access; 118 enum bpf_return_type ret_type; 119 enum bpf_arg_type arg1_type; 120 enum bpf_arg_type arg2_type; 121 enum bpf_arg_type arg3_type; 122 enum bpf_arg_type arg4_type; 123 enum bpf_arg_type arg5_type; 124 }; 125 126 /* bpf_context is intentionally undefined structure. Pointer to bpf_context is 127 * the first argument to eBPF programs. 128 * For socket filters: 'struct bpf_context *' == 'struct sk_buff *' 129 */ 130 struct bpf_context; 131 132 enum bpf_access_type { 133 BPF_READ = 1, 134 BPF_WRITE = 2 135 }; 136 137 /* types of values stored in eBPF registers */ 138 /* Pointer types represent: 139 * pointer 140 * pointer + imm 141 * pointer + (u16) var 142 * pointer + (u16) var + imm 143 * if (range > 0) then [ptr, ptr + range - off) is safe to access 144 * if (id > 0) means that some 'var' was added 145 * if (off > 0) means that 'imm' was added 146 */ 147 enum bpf_reg_type { 148 NOT_INIT = 0, /* nothing was written into register */ 149 SCALAR_VALUE, /* reg doesn't contain a valid pointer */ 150 PTR_TO_CTX, /* reg points to bpf_context */ 151 CONST_PTR_TO_MAP, /* reg points to struct bpf_map */ 152 PTR_TO_MAP_VALUE, /* reg points to map element value */ 153 PTR_TO_MAP_VALUE_OR_NULL,/* points to map elem value or NULL */ 154 PTR_TO_STACK, /* reg == frame_pointer + offset */ 155 PTR_TO_PACKET_META, /* skb->data - meta_len */ 156 PTR_TO_PACKET, /* reg points to skb->data */ 157 PTR_TO_PACKET_END, /* skb->data + headlen */ 158 }; 159 160 /* The information passed from prog-specific *_is_valid_access 161 * back to the verifier. 162 */ 163 struct bpf_insn_access_aux { 164 enum bpf_reg_type reg_type; 165 int ctx_field_size; 166 }; 167 168 static inline void 169 bpf_ctx_record_field_size(struct bpf_insn_access_aux *aux, u32 size) 170 { 171 aux->ctx_field_size = size; 172 } 173 174 struct bpf_prog_ops { 175 int (*test_run)(struct bpf_prog *prog, const union bpf_attr *kattr, 176 union bpf_attr __user *uattr); 177 }; 178 179 struct bpf_verifier_ops { 180 /* return eBPF function prototype for verification */ 181 const struct bpf_func_proto *(*get_func_proto)(enum bpf_func_id func_id); 182 183 /* return true if 'size' wide access at offset 'off' within bpf_context 184 * with 'type' (read or write) is allowed 185 */ 186 bool (*is_valid_access)(int off, int size, enum bpf_access_type type, 187 struct bpf_insn_access_aux *info); 188 int (*gen_prologue)(struct bpf_insn *insn, bool direct_write, 189 const struct bpf_prog *prog); 190 u32 (*convert_ctx_access)(enum bpf_access_type type, 191 const struct bpf_insn *src, 192 struct bpf_insn *dst, 193 struct bpf_prog *prog, u32 *target_size); 194 }; 195 196 struct bpf_dev_offload { 197 struct bpf_prog *prog; 198 struct net_device *netdev; 199 void *dev_priv; 200 struct list_head offloads; 201 bool dev_state; 202 bool verifier_running; 203 wait_queue_head_t verifier_done; 204 }; 205 206 struct bpf_prog_aux { 207 atomic_t refcnt; 208 u32 used_map_cnt; 209 u32 max_ctx_offset; 210 u32 stack_depth; 211 u32 id; 212 struct latch_tree_node ksym_tnode; 213 struct list_head ksym_lnode; 214 const struct bpf_prog_ops *ops; 215 struct bpf_map **used_maps; 216 struct bpf_prog *prog; 217 struct user_struct *user; 218 u64 load_time; /* ns since boottime */ 219 char name[BPF_OBJ_NAME_LEN]; 220 #ifdef CONFIG_SECURITY 221 void *security; 222 #endif 223 struct bpf_dev_offload *offload; 224 union { 225 struct work_struct work; 226 struct rcu_head rcu; 227 }; 228 }; 229 230 struct bpf_array { 231 struct bpf_map map; 232 u32 elem_size; 233 u32 index_mask; 234 /* 'ownership' of prog_array is claimed by the first program that 235 * is going to use this map or by the first program which FD is stored 236 * in the map to make sure that all callers and callees have the same 237 * prog_type and JITed flag 238 */ 239 enum bpf_prog_type owner_prog_type; 240 bool owner_jited; 241 union { 242 char value[0] __aligned(8); 243 void *ptrs[0] __aligned(8); 244 void __percpu *pptrs[0] __aligned(8); 245 }; 246 }; 247 248 #define MAX_TAIL_CALL_CNT 32 249 250 struct bpf_event_entry { 251 struct perf_event *event; 252 struct file *perf_file; 253 struct file *map_file; 254 struct rcu_head rcu; 255 }; 256 257 bool bpf_prog_array_compatible(struct bpf_array *array, const struct bpf_prog *fp); 258 int bpf_prog_calc_tag(struct bpf_prog *fp); 259 260 const struct bpf_func_proto *bpf_get_trace_printk_proto(void); 261 262 typedef unsigned long (*bpf_ctx_copy_t)(void *dst, const void *src, 263 unsigned long off, unsigned long len); 264 265 u64 bpf_event_output(struct bpf_map *map, u64 flags, void *meta, u64 meta_size, 266 void *ctx, u64 ctx_size, bpf_ctx_copy_t ctx_copy); 267 268 int bpf_prog_test_run_xdp(struct bpf_prog *prog, const union bpf_attr *kattr, 269 union bpf_attr __user *uattr); 270 int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr, 271 union bpf_attr __user *uattr); 272 273 /* an array of programs to be executed under rcu_lock. 274 * 275 * Typical usage: 276 * ret = BPF_PROG_RUN_ARRAY(&bpf_prog_array, ctx, BPF_PROG_RUN); 277 * 278 * the structure returned by bpf_prog_array_alloc() should be populated 279 * with program pointers and the last pointer must be NULL. 280 * The user has to keep refcnt on the program and make sure the program 281 * is removed from the array before bpf_prog_put(). 282 * The 'struct bpf_prog_array *' should only be replaced with xchg() 283 * since other cpus are walking the array of pointers in parallel. 284 */ 285 struct bpf_prog_array { 286 struct rcu_head rcu; 287 struct bpf_prog *progs[0]; 288 }; 289 290 struct bpf_prog_array __rcu *bpf_prog_array_alloc(u32 prog_cnt, gfp_t flags); 291 void bpf_prog_array_free(struct bpf_prog_array __rcu *progs); 292 int bpf_prog_array_length(struct bpf_prog_array __rcu *progs); 293 int bpf_prog_array_copy_to_user(struct bpf_prog_array __rcu *progs, 294 __u32 __user *prog_ids, u32 cnt); 295 296 void bpf_prog_array_delete_safe(struct bpf_prog_array __rcu *progs, 297 struct bpf_prog *old_prog); 298 int bpf_prog_array_copy(struct bpf_prog_array __rcu *old_array, 299 struct bpf_prog *exclude_prog, 300 struct bpf_prog *include_prog, 301 struct bpf_prog_array **new_array); 302 303 #define __BPF_PROG_RUN_ARRAY(array, ctx, func, check_non_null) \ 304 ({ \ 305 struct bpf_prog **_prog, *__prog; \ 306 struct bpf_prog_array *_array; \ 307 u32 _ret = 1; \ 308 rcu_read_lock(); \ 309 _array = rcu_dereference(array); \ 310 if (unlikely(check_non_null && !_array))\ 311 goto _out; \ 312 _prog = _array->progs; \ 313 while ((__prog = READ_ONCE(*_prog))) { \ 314 _ret &= func(__prog, ctx); \ 315 _prog++; \ 316 } \ 317 _out: \ 318 rcu_read_unlock(); \ 319 _ret; \ 320 }) 321 322 #define BPF_PROG_RUN_ARRAY(array, ctx, func) \ 323 __BPF_PROG_RUN_ARRAY(array, ctx, func, false) 324 325 #define BPF_PROG_RUN_ARRAY_CHECK(array, ctx, func) \ 326 __BPF_PROG_RUN_ARRAY(array, ctx, func, true) 327 328 #ifdef CONFIG_BPF_SYSCALL 329 DECLARE_PER_CPU(int, bpf_prog_active); 330 331 extern const struct file_operations bpf_map_fops; 332 extern const struct file_operations bpf_prog_fops; 333 334 #define BPF_PROG_TYPE(_id, _name) \ 335 extern const struct bpf_prog_ops _name ## _prog_ops; \ 336 extern const struct bpf_verifier_ops _name ## _verifier_ops; 337 #define BPF_MAP_TYPE(_id, _ops) \ 338 extern const struct bpf_map_ops _ops; 339 #include <linux/bpf_types.h> 340 #undef BPF_PROG_TYPE 341 #undef BPF_MAP_TYPE 342 343 extern const struct bpf_prog_ops bpf_offload_prog_ops; 344 extern const struct bpf_verifier_ops tc_cls_act_analyzer_ops; 345 extern const struct bpf_verifier_ops xdp_analyzer_ops; 346 347 struct bpf_prog *bpf_prog_get(u32 ufd); 348 struct bpf_prog *bpf_prog_get_type_dev(u32 ufd, enum bpf_prog_type type, 349 bool attach_drv); 350 struct bpf_prog * __must_check bpf_prog_add(struct bpf_prog *prog, int i); 351 void bpf_prog_sub(struct bpf_prog *prog, int i); 352 struct bpf_prog * __must_check bpf_prog_inc(struct bpf_prog *prog); 353 struct bpf_prog * __must_check bpf_prog_inc_not_zero(struct bpf_prog *prog); 354 void bpf_prog_put(struct bpf_prog *prog); 355 int __bpf_prog_charge(struct user_struct *user, u32 pages); 356 void __bpf_prog_uncharge(struct user_struct *user, u32 pages); 357 358 struct bpf_map *bpf_map_get_with_uref(u32 ufd); 359 struct bpf_map *__bpf_map_get(struct fd f); 360 struct bpf_map * __must_check bpf_map_inc(struct bpf_map *map, bool uref); 361 void bpf_map_put_with_uref(struct bpf_map *map); 362 void bpf_map_put(struct bpf_map *map); 363 int bpf_map_precharge_memlock(u32 pages); 364 void *bpf_map_area_alloc(size_t size, int numa_node); 365 void bpf_map_area_free(void *base); 366 367 extern int sysctl_unprivileged_bpf_disabled; 368 369 int bpf_map_new_fd(struct bpf_map *map, int flags); 370 int bpf_prog_new_fd(struct bpf_prog *prog); 371 372 int bpf_obj_pin_user(u32 ufd, const char __user *pathname); 373 int bpf_obj_get_user(const char __user *pathname, int flags); 374 375 int bpf_percpu_hash_copy(struct bpf_map *map, void *key, void *value); 376 int bpf_percpu_array_copy(struct bpf_map *map, void *key, void *value); 377 int bpf_percpu_hash_update(struct bpf_map *map, void *key, void *value, 378 u64 flags); 379 int bpf_percpu_array_update(struct bpf_map *map, void *key, void *value, 380 u64 flags); 381 382 int bpf_stackmap_copy(struct bpf_map *map, void *key, void *value); 383 384 int bpf_fd_array_map_update_elem(struct bpf_map *map, struct file *map_file, 385 void *key, void *value, u64 map_flags); 386 int bpf_fd_array_map_lookup_elem(struct bpf_map *map, void *key, u32 *value); 387 void bpf_fd_array_map_clear(struct bpf_map *map); 388 int bpf_fd_htab_map_update_elem(struct bpf_map *map, struct file *map_file, 389 void *key, void *value, u64 map_flags); 390 int bpf_fd_htab_map_lookup_elem(struct bpf_map *map, void *key, u32 *value); 391 392 int bpf_get_file_flag(int flags); 393 394 /* memcpy that is used with 8-byte aligned pointers, power-of-8 size and 395 * forced to use 'long' read/writes to try to atomically copy long counters. 396 * Best-effort only. No barriers here, since it _will_ race with concurrent 397 * updates from BPF programs. Called from bpf syscall and mostly used with 398 * size 8 or 16 bytes, so ask compiler to inline it. 399 */ 400 static inline void bpf_long_memcpy(void *dst, const void *src, u32 size) 401 { 402 const long *lsrc = src; 403 long *ldst = dst; 404 405 size /= sizeof(long); 406 while (size--) 407 *ldst++ = *lsrc++; 408 } 409 410 /* verify correctness of eBPF program */ 411 int bpf_check(struct bpf_prog **fp, union bpf_attr *attr); 412 413 /* Map specifics */ 414 struct net_device *__dev_map_lookup_elem(struct bpf_map *map, u32 key); 415 void __dev_map_insert_ctx(struct bpf_map *map, u32 index); 416 void __dev_map_flush(struct bpf_map *map); 417 418 struct bpf_cpu_map_entry *__cpu_map_lookup_elem(struct bpf_map *map, u32 key); 419 void __cpu_map_insert_ctx(struct bpf_map *map, u32 index); 420 void __cpu_map_flush(struct bpf_map *map); 421 struct xdp_buff; 422 int cpu_map_enqueue(struct bpf_cpu_map_entry *rcpu, struct xdp_buff *xdp, 423 struct net_device *dev_rx); 424 425 /* Return map's numa specified by userspace */ 426 static inline int bpf_map_attr_numa_node(const union bpf_attr *attr) 427 { 428 return (attr->map_flags & BPF_F_NUMA_NODE) ? 429 attr->numa_node : NUMA_NO_NODE; 430 } 431 432 struct bpf_prog *bpf_prog_get_type_path(const char *name, enum bpf_prog_type type); 433 434 #else /* !CONFIG_BPF_SYSCALL */ 435 static inline struct bpf_prog *bpf_prog_get(u32 ufd) 436 { 437 return ERR_PTR(-EOPNOTSUPP); 438 } 439 440 static inline struct bpf_prog *bpf_prog_get_type_dev(u32 ufd, 441 enum bpf_prog_type type, 442 bool attach_drv) 443 { 444 return ERR_PTR(-EOPNOTSUPP); 445 } 446 447 static inline struct bpf_prog * __must_check bpf_prog_add(struct bpf_prog *prog, 448 int i) 449 { 450 return ERR_PTR(-EOPNOTSUPP); 451 } 452 453 static inline void bpf_prog_sub(struct bpf_prog *prog, int i) 454 { 455 } 456 457 static inline void bpf_prog_put(struct bpf_prog *prog) 458 { 459 } 460 461 static inline struct bpf_prog * __must_check bpf_prog_inc(struct bpf_prog *prog) 462 { 463 return ERR_PTR(-EOPNOTSUPP); 464 } 465 466 static inline struct bpf_prog *__must_check 467 bpf_prog_inc_not_zero(struct bpf_prog *prog) 468 { 469 return ERR_PTR(-EOPNOTSUPP); 470 } 471 472 static inline int __bpf_prog_charge(struct user_struct *user, u32 pages) 473 { 474 return 0; 475 } 476 477 static inline void __bpf_prog_uncharge(struct user_struct *user, u32 pages) 478 { 479 } 480 481 static inline int bpf_obj_get_user(const char __user *pathname, int flags) 482 { 483 return -EOPNOTSUPP; 484 } 485 486 static inline struct net_device *__dev_map_lookup_elem(struct bpf_map *map, 487 u32 key) 488 { 489 return NULL; 490 } 491 492 static inline void __dev_map_insert_ctx(struct bpf_map *map, u32 index) 493 { 494 } 495 496 static inline void __dev_map_flush(struct bpf_map *map) 497 { 498 } 499 500 static inline 501 struct bpf_cpu_map_entry *__cpu_map_lookup_elem(struct bpf_map *map, u32 key) 502 { 503 return NULL; 504 } 505 506 static inline void __cpu_map_insert_ctx(struct bpf_map *map, u32 index) 507 { 508 } 509 510 static inline void __cpu_map_flush(struct bpf_map *map) 511 { 512 } 513 514 struct xdp_buff; 515 static inline int cpu_map_enqueue(struct bpf_cpu_map_entry *rcpu, 516 struct xdp_buff *xdp, 517 struct net_device *dev_rx) 518 { 519 return 0; 520 } 521 522 static inline struct bpf_prog *bpf_prog_get_type_path(const char *name, 523 enum bpf_prog_type type) 524 { 525 return ERR_PTR(-EOPNOTSUPP); 526 } 527 #endif /* CONFIG_BPF_SYSCALL */ 528 529 static inline struct bpf_prog *bpf_prog_get_type(u32 ufd, 530 enum bpf_prog_type type) 531 { 532 return bpf_prog_get_type_dev(ufd, type, false); 533 } 534 535 bool bpf_prog_get_ok(struct bpf_prog *, enum bpf_prog_type *, bool); 536 537 int bpf_prog_offload_compile(struct bpf_prog *prog); 538 void bpf_prog_offload_destroy(struct bpf_prog *prog); 539 540 #if defined(CONFIG_NET) && defined(CONFIG_BPF_SYSCALL) 541 int bpf_prog_offload_init(struct bpf_prog *prog, union bpf_attr *attr); 542 543 static inline bool bpf_prog_is_dev_bound(struct bpf_prog_aux *aux) 544 { 545 return aux->offload; 546 } 547 #else 548 static inline int bpf_prog_offload_init(struct bpf_prog *prog, 549 union bpf_attr *attr) 550 { 551 return -EOPNOTSUPP; 552 } 553 554 static inline bool bpf_prog_is_dev_bound(struct bpf_prog_aux *aux) 555 { 556 return false; 557 } 558 #endif /* CONFIG_NET && CONFIG_BPF_SYSCALL */ 559 560 #if defined(CONFIG_STREAM_PARSER) && defined(CONFIG_BPF_SYSCALL) 561 struct sock *__sock_map_lookup_elem(struct bpf_map *map, u32 key); 562 int sock_map_prog(struct bpf_map *map, struct bpf_prog *prog, u32 type); 563 #else 564 static inline struct sock *__sock_map_lookup_elem(struct bpf_map *map, u32 key) 565 { 566 return NULL; 567 } 568 569 static inline int sock_map_prog(struct bpf_map *map, 570 struct bpf_prog *prog, 571 u32 type) 572 { 573 return -EOPNOTSUPP; 574 } 575 #endif 576 577 /* verifier prototypes for helper functions called from eBPF programs */ 578 extern const struct bpf_func_proto bpf_map_lookup_elem_proto; 579 extern const struct bpf_func_proto bpf_map_update_elem_proto; 580 extern const struct bpf_func_proto bpf_map_delete_elem_proto; 581 582 extern const struct bpf_func_proto bpf_get_prandom_u32_proto; 583 extern const struct bpf_func_proto bpf_get_smp_processor_id_proto; 584 extern const struct bpf_func_proto bpf_get_numa_node_id_proto; 585 extern const struct bpf_func_proto bpf_tail_call_proto; 586 extern const struct bpf_func_proto bpf_ktime_get_ns_proto; 587 extern const struct bpf_func_proto bpf_get_current_pid_tgid_proto; 588 extern const struct bpf_func_proto bpf_get_current_uid_gid_proto; 589 extern const struct bpf_func_proto bpf_get_current_comm_proto; 590 extern const struct bpf_func_proto bpf_skb_vlan_push_proto; 591 extern const struct bpf_func_proto bpf_skb_vlan_pop_proto; 592 extern const struct bpf_func_proto bpf_get_stackid_proto; 593 extern const struct bpf_func_proto bpf_sock_map_update_proto; 594 595 /* Shared helpers among cBPF and eBPF. */ 596 void bpf_user_rnd_init_once(void); 597 u64 bpf_user_rnd_u32(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5); 598 599 #endif /* _LINUX_BPF_H */ 600