1 /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ 2 /* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of version 2 of the GNU General Public 6 * License as published by the Free Software Foundation. 7 */ 8 #ifndef _UAPI__LINUX_BPF_H__ 9 #define _UAPI__LINUX_BPF_H__ 10 11 #include <linux/types.h> 12 #include <linux/bpf_common.h> 13 14 /* Extended instruction set based on top of classic BPF */ 15 16 /* instruction classes */ 17 #define BPF_ALU64 0x07 /* alu mode in double word width */ 18 19 /* ld/ldx fields */ 20 #define BPF_DW 0x18 /* double word (64-bit) */ 21 #define BPF_XADD 0xc0 /* exclusive add */ 22 23 /* alu/jmp fields */ 24 #define BPF_MOV 0xb0 /* mov reg to reg */ 25 #define BPF_ARSH 0xc0 /* sign extending arithmetic shift right */ 26 27 /* change endianness of a register */ 28 #define BPF_END 0xd0 /* flags for endianness conversion: */ 29 #define BPF_TO_LE 0x00 /* convert to little-endian */ 30 #define BPF_TO_BE 0x08 /* convert to big-endian */ 31 #define BPF_FROM_LE BPF_TO_LE 32 #define BPF_FROM_BE BPF_TO_BE 33 34 /* jmp encodings */ 35 #define BPF_JNE 0x50 /* jump != */ 36 #define BPF_JLT 0xa0 /* LT is unsigned, '<' */ 37 #define BPF_JLE 0xb0 /* LE is unsigned, '<=' */ 38 #define BPF_JSGT 0x60 /* SGT is signed '>', GT in x86 */ 39 #define BPF_JSGE 0x70 /* SGE is signed '>=', GE in x86 */ 40 #define BPF_JSLT 0xc0 /* SLT is signed, '<' */ 41 #define BPF_JSLE 0xd0 /* SLE is signed, '<=' */ 42 #define BPF_CALL 0x80 /* function call */ 43 #define BPF_EXIT 0x90 /* function return */ 44 45 /* Register numbers */ 46 enum { 47 BPF_REG_0 = 0, 48 BPF_REG_1, 49 BPF_REG_2, 50 BPF_REG_3, 51 BPF_REG_4, 52 BPF_REG_5, 53 BPF_REG_6, 54 BPF_REG_7, 55 BPF_REG_8, 56 BPF_REG_9, 57 BPF_REG_10, 58 __MAX_BPF_REG, 59 }; 60 61 /* BPF has 10 general purpose 64-bit registers and stack frame. */ 62 #define MAX_BPF_REG __MAX_BPF_REG 63 64 struct bpf_insn { 65 __u8 code; /* opcode */ 66 __u8 dst_reg:4; /* dest register */ 67 __u8 src_reg:4; /* source register */ 68 __s16 off; /* signed offset */ 69 __s32 imm; /* signed immediate constant */ 70 }; 71 72 /* Key of an a BPF_MAP_TYPE_LPM_TRIE entry */ 73 struct bpf_lpm_trie_key { 74 __u32 prefixlen; /* up to 32 for AF_INET, 128 for AF_INET6 */ 75 __u8 data[0]; /* Arbitrary size */ 76 }; 77 78 /* BPF syscall commands, see bpf(2) man-page for details. */ 79 enum bpf_cmd { 80 BPF_MAP_CREATE, 81 BPF_MAP_LOOKUP_ELEM, 82 BPF_MAP_UPDATE_ELEM, 83 BPF_MAP_DELETE_ELEM, 84 BPF_MAP_GET_NEXT_KEY, 85 BPF_PROG_LOAD, 86 BPF_OBJ_PIN, 87 BPF_OBJ_GET, 88 BPF_PROG_ATTACH, 89 BPF_PROG_DETACH, 90 BPF_PROG_TEST_RUN, 91 BPF_PROG_GET_NEXT_ID, 92 BPF_MAP_GET_NEXT_ID, 93 BPF_PROG_GET_FD_BY_ID, 94 BPF_MAP_GET_FD_BY_ID, 95 BPF_OBJ_GET_INFO_BY_FD, 96 BPF_PROG_QUERY, 97 BPF_RAW_TRACEPOINT_OPEN, 98 }; 99 100 enum bpf_map_type { 101 BPF_MAP_TYPE_UNSPEC, 102 BPF_MAP_TYPE_HASH, 103 BPF_MAP_TYPE_ARRAY, 104 BPF_MAP_TYPE_PROG_ARRAY, 105 BPF_MAP_TYPE_PERF_EVENT_ARRAY, 106 BPF_MAP_TYPE_PERCPU_HASH, 107 BPF_MAP_TYPE_PERCPU_ARRAY, 108 BPF_MAP_TYPE_STACK_TRACE, 109 BPF_MAP_TYPE_CGROUP_ARRAY, 110 BPF_MAP_TYPE_LRU_HASH, 111 BPF_MAP_TYPE_LRU_PERCPU_HASH, 112 BPF_MAP_TYPE_LPM_TRIE, 113 BPF_MAP_TYPE_ARRAY_OF_MAPS, 114 BPF_MAP_TYPE_HASH_OF_MAPS, 115 BPF_MAP_TYPE_DEVMAP, 116 BPF_MAP_TYPE_SOCKMAP, 117 BPF_MAP_TYPE_CPUMAP, 118 }; 119 120 enum bpf_prog_type { 121 BPF_PROG_TYPE_UNSPEC, 122 BPF_PROG_TYPE_SOCKET_FILTER, 123 BPF_PROG_TYPE_KPROBE, 124 BPF_PROG_TYPE_SCHED_CLS, 125 BPF_PROG_TYPE_SCHED_ACT, 126 BPF_PROG_TYPE_TRACEPOINT, 127 BPF_PROG_TYPE_XDP, 128 BPF_PROG_TYPE_PERF_EVENT, 129 BPF_PROG_TYPE_CGROUP_SKB, 130 BPF_PROG_TYPE_CGROUP_SOCK, 131 BPF_PROG_TYPE_LWT_IN, 132 BPF_PROG_TYPE_LWT_OUT, 133 BPF_PROG_TYPE_LWT_XMIT, 134 BPF_PROG_TYPE_SOCK_OPS, 135 BPF_PROG_TYPE_SK_SKB, 136 BPF_PROG_TYPE_CGROUP_DEVICE, 137 BPF_PROG_TYPE_SK_MSG, 138 BPF_PROG_TYPE_RAW_TRACEPOINT, 139 BPF_PROG_TYPE_CGROUP_SOCK_ADDR, 140 }; 141 142 enum bpf_attach_type { 143 BPF_CGROUP_INET_INGRESS, 144 BPF_CGROUP_INET_EGRESS, 145 BPF_CGROUP_INET_SOCK_CREATE, 146 BPF_CGROUP_SOCK_OPS, 147 BPF_SK_SKB_STREAM_PARSER, 148 BPF_SK_SKB_STREAM_VERDICT, 149 BPF_CGROUP_DEVICE, 150 BPF_SK_MSG_VERDICT, 151 BPF_CGROUP_INET4_BIND, 152 BPF_CGROUP_INET6_BIND, 153 BPF_CGROUP_INET4_CONNECT, 154 BPF_CGROUP_INET6_CONNECT, 155 BPF_CGROUP_INET4_POST_BIND, 156 BPF_CGROUP_INET6_POST_BIND, 157 __MAX_BPF_ATTACH_TYPE 158 }; 159 160 #define MAX_BPF_ATTACH_TYPE __MAX_BPF_ATTACH_TYPE 161 162 /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command 163 * 164 * NONE(default): No further bpf programs allowed in the subtree. 165 * 166 * BPF_F_ALLOW_OVERRIDE: If a sub-cgroup installs some bpf program, 167 * the program in this cgroup yields to sub-cgroup program. 168 * 169 * BPF_F_ALLOW_MULTI: If a sub-cgroup installs some bpf program, 170 * that cgroup program gets run in addition to the program in this cgroup. 171 * 172 * Only one program is allowed to be attached to a cgroup with 173 * NONE or BPF_F_ALLOW_OVERRIDE flag. 174 * Attaching another program on top of NONE or BPF_F_ALLOW_OVERRIDE will 175 * release old program and attach the new one. Attach flags has to match. 176 * 177 * Multiple programs are allowed to be attached to a cgroup with 178 * BPF_F_ALLOW_MULTI flag. They are executed in FIFO order 179 * (those that were attached first, run first) 180 * The programs of sub-cgroup are executed first, then programs of 181 * this cgroup and then programs of parent cgroup. 182 * When children program makes decision (like picking TCP CA or sock bind) 183 * parent program has a chance to override it. 184 * 185 * A cgroup with MULTI or OVERRIDE flag allows any attach flags in sub-cgroups. 186 * A cgroup with NONE doesn't allow any programs in sub-cgroups. 187 * Ex1: 188 * cgrp1 (MULTI progs A, B) -> 189 * cgrp2 (OVERRIDE prog C) -> 190 * cgrp3 (MULTI prog D) -> 191 * cgrp4 (OVERRIDE prog E) -> 192 * cgrp5 (NONE prog F) 193 * the event in cgrp5 triggers execution of F,D,A,B in that order. 194 * if prog F is detached, the execution is E,D,A,B 195 * if prog F and D are detached, the execution is E,A,B 196 * if prog F, E and D are detached, the execution is C,A,B 197 * 198 * All eligible programs are executed regardless of return code from 199 * earlier programs. 200 */ 201 #define BPF_F_ALLOW_OVERRIDE (1U << 0) 202 #define BPF_F_ALLOW_MULTI (1U << 1) 203 204 /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the 205 * verifier will perform strict alignment checking as if the kernel 206 * has been built with CONFIG_EFFICIENT_UNALIGNED_ACCESS not set, 207 * and NET_IP_ALIGN defined to 2. 208 */ 209 #define BPF_F_STRICT_ALIGNMENT (1U << 0) 210 211 /* when bpf_ldimm64->src_reg == BPF_PSEUDO_MAP_FD, bpf_ldimm64->imm == fd */ 212 #define BPF_PSEUDO_MAP_FD 1 213 214 /* when bpf_call->src_reg == BPF_PSEUDO_CALL, bpf_call->imm == pc-relative 215 * offset to another bpf function 216 */ 217 #define BPF_PSEUDO_CALL 1 218 219 /* flags for BPF_MAP_UPDATE_ELEM command */ 220 #define BPF_ANY 0 /* create new element or update existing */ 221 #define BPF_NOEXIST 1 /* create new element if it didn't exist */ 222 #define BPF_EXIST 2 /* update existing element */ 223 224 /* flags for BPF_MAP_CREATE command */ 225 #define BPF_F_NO_PREALLOC (1U << 0) 226 /* Instead of having one common LRU list in the 227 * BPF_MAP_TYPE_LRU_[PERCPU_]HASH map, use a percpu LRU list 228 * which can scale and perform better. 229 * Note, the LRU nodes (including free nodes) cannot be moved 230 * across different LRU lists. 231 */ 232 #define BPF_F_NO_COMMON_LRU (1U << 1) 233 /* Specify numa node during map creation */ 234 #define BPF_F_NUMA_NODE (1U << 2) 235 236 /* flags for BPF_PROG_QUERY */ 237 #define BPF_F_QUERY_EFFECTIVE (1U << 0) 238 239 #define BPF_OBJ_NAME_LEN 16U 240 241 /* Flags for accessing BPF object */ 242 #define BPF_F_RDONLY (1U << 3) 243 #define BPF_F_WRONLY (1U << 4) 244 245 /* Flag for stack_map, store build_id+offset instead of pointer */ 246 #define BPF_F_STACK_BUILD_ID (1U << 5) 247 248 enum bpf_stack_build_id_status { 249 /* user space need an empty entry to identify end of a trace */ 250 BPF_STACK_BUILD_ID_EMPTY = 0, 251 /* with valid build_id and offset */ 252 BPF_STACK_BUILD_ID_VALID = 1, 253 /* couldn't get build_id, fallback to ip */ 254 BPF_STACK_BUILD_ID_IP = 2, 255 }; 256 257 #define BPF_BUILD_ID_SIZE 20 258 struct bpf_stack_build_id { 259 __s32 status; 260 unsigned char build_id[BPF_BUILD_ID_SIZE]; 261 union { 262 __u64 offset; 263 __u64 ip; 264 }; 265 }; 266 267 union bpf_attr { 268 struct { /* anonymous struct used by BPF_MAP_CREATE command */ 269 __u32 map_type; /* one of enum bpf_map_type */ 270 __u32 key_size; /* size of key in bytes */ 271 __u32 value_size; /* size of value in bytes */ 272 __u32 max_entries; /* max number of entries in a map */ 273 __u32 map_flags; /* BPF_MAP_CREATE related 274 * flags defined above. 275 */ 276 __u32 inner_map_fd; /* fd pointing to the inner map */ 277 __u32 numa_node; /* numa node (effective only if 278 * BPF_F_NUMA_NODE is set). 279 */ 280 char map_name[BPF_OBJ_NAME_LEN]; 281 __u32 map_ifindex; /* ifindex of netdev to create on */ 282 }; 283 284 struct { /* anonymous struct used by BPF_MAP_*_ELEM commands */ 285 __u32 map_fd; 286 __aligned_u64 key; 287 union { 288 __aligned_u64 value; 289 __aligned_u64 next_key; 290 }; 291 __u64 flags; 292 }; 293 294 struct { /* anonymous struct used by BPF_PROG_LOAD command */ 295 __u32 prog_type; /* one of enum bpf_prog_type */ 296 __u32 insn_cnt; 297 __aligned_u64 insns; 298 __aligned_u64 license; 299 __u32 log_level; /* verbosity level of verifier */ 300 __u32 log_size; /* size of user buffer */ 301 __aligned_u64 log_buf; /* user supplied buffer */ 302 __u32 kern_version; /* checked when prog_type=kprobe */ 303 __u32 prog_flags; 304 char prog_name[BPF_OBJ_NAME_LEN]; 305 __u32 prog_ifindex; /* ifindex of netdev to prep for */ 306 /* For some prog types expected attach type must be known at 307 * load time to verify attach type specific parts of prog 308 * (context accesses, allowed helpers, etc). 309 */ 310 __u32 expected_attach_type; 311 }; 312 313 struct { /* anonymous struct used by BPF_OBJ_* commands */ 314 __aligned_u64 pathname; 315 __u32 bpf_fd; 316 __u32 file_flags; 317 }; 318 319 struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ 320 __u32 target_fd; /* container object to attach to */ 321 __u32 attach_bpf_fd; /* eBPF program to attach */ 322 __u32 attach_type; 323 __u32 attach_flags; 324 }; 325 326 struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */ 327 __u32 prog_fd; 328 __u32 retval; 329 __u32 data_size_in; 330 __u32 data_size_out; 331 __aligned_u64 data_in; 332 __aligned_u64 data_out; 333 __u32 repeat; 334 __u32 duration; 335 } test; 336 337 struct { /* anonymous struct used by BPF_*_GET_*_ID */ 338 union { 339 __u32 start_id; 340 __u32 prog_id; 341 __u32 map_id; 342 }; 343 __u32 next_id; 344 __u32 open_flags; 345 }; 346 347 struct { /* anonymous struct used by BPF_OBJ_GET_INFO_BY_FD */ 348 __u32 bpf_fd; 349 __u32 info_len; 350 __aligned_u64 info; 351 } info; 352 353 struct { /* anonymous struct used by BPF_PROG_QUERY command */ 354 __u32 target_fd; /* container object to query */ 355 __u32 attach_type; 356 __u32 query_flags; 357 __u32 attach_flags; 358 __aligned_u64 prog_ids; 359 __u32 prog_cnt; 360 } query; 361 362 struct { 363 __u64 name; 364 __u32 prog_fd; 365 } raw_tracepoint; 366 } __attribute__((aligned(8))); 367 368 /* BPF helper function descriptions: 369 * 370 * void *bpf_map_lookup_elem(&map, &key) 371 * Return: Map value or NULL 372 * 373 * int bpf_map_update_elem(&map, &key, &value, flags) 374 * Return: 0 on success or negative error 375 * 376 * int bpf_map_delete_elem(&map, &key) 377 * Return: 0 on success or negative error 378 * 379 * int bpf_probe_read(void *dst, int size, void *src) 380 * Return: 0 on success or negative error 381 * 382 * u64 bpf_ktime_get_ns(void) 383 * Return: current ktime 384 * 385 * int bpf_trace_printk(const char *fmt, int fmt_size, ...) 386 * Return: length of buffer written or negative error 387 * 388 * u32 bpf_prandom_u32(void) 389 * Return: random value 390 * 391 * u32 bpf_raw_smp_processor_id(void) 392 * Return: SMP processor ID 393 * 394 * int bpf_skb_store_bytes(skb, offset, from, len, flags) 395 * store bytes into packet 396 * @skb: pointer to skb 397 * @offset: offset within packet from skb->mac_header 398 * @from: pointer where to copy bytes from 399 * @len: number of bytes to store into packet 400 * @flags: bit 0 - if true, recompute skb->csum 401 * other bits - reserved 402 * Return: 0 on success or negative error 403 * 404 * int bpf_l3_csum_replace(skb, offset, from, to, flags) 405 * recompute IP checksum 406 * @skb: pointer to skb 407 * @offset: offset within packet where IP checksum is located 408 * @from: old value of header field 409 * @to: new value of header field 410 * @flags: bits 0-3 - size of header field 411 * other bits - reserved 412 * Return: 0 on success or negative error 413 * 414 * int bpf_l4_csum_replace(skb, offset, from, to, flags) 415 * recompute TCP/UDP checksum 416 * @skb: pointer to skb 417 * @offset: offset within packet where TCP/UDP checksum is located 418 * @from: old value of header field 419 * @to: new value of header field 420 * @flags: bits 0-3 - size of header field 421 * bit 4 - is pseudo header 422 * other bits - reserved 423 * Return: 0 on success or negative error 424 * 425 * int bpf_tail_call(ctx, prog_array_map, index) 426 * jump into another BPF program 427 * @ctx: context pointer passed to next program 428 * @prog_array_map: pointer to map which type is BPF_MAP_TYPE_PROG_ARRAY 429 * @index: 32-bit index inside array that selects specific program to run 430 * Return: 0 on success or negative error 431 * 432 * int bpf_clone_redirect(skb, ifindex, flags) 433 * redirect to another netdev 434 * @skb: pointer to skb 435 * @ifindex: ifindex of the net device 436 * @flags: bit 0 - if set, redirect to ingress instead of egress 437 * other bits - reserved 438 * Return: 0 on success or negative error 439 * 440 * u64 bpf_get_current_pid_tgid(void) 441 * Return: current->tgid << 32 | current->pid 442 * 443 * u64 bpf_get_current_uid_gid(void) 444 * Return: current_gid << 32 | current_uid 445 * 446 * int bpf_get_current_comm(char *buf, int size_of_buf) 447 * stores current->comm into buf 448 * Return: 0 on success or negative error 449 * 450 * u32 bpf_get_cgroup_classid(skb) 451 * retrieve a proc's classid 452 * @skb: pointer to skb 453 * Return: classid if != 0 454 * 455 * int bpf_skb_vlan_push(skb, vlan_proto, vlan_tci) 456 * Return: 0 on success or negative error 457 * 458 * int bpf_skb_vlan_pop(skb) 459 * Return: 0 on success or negative error 460 * 461 * int bpf_skb_get_tunnel_key(skb, key, size, flags) 462 * int bpf_skb_set_tunnel_key(skb, key, size, flags) 463 * retrieve or populate tunnel metadata 464 * @skb: pointer to skb 465 * @key: pointer to 'struct bpf_tunnel_key' 466 * @size: size of 'struct bpf_tunnel_key' 467 * @flags: room for future extensions 468 * Return: 0 on success or negative error 469 * 470 * u64 bpf_perf_event_read(map, flags) 471 * read perf event counter value 472 * @map: pointer to perf_event_array map 473 * @flags: index of event in the map or bitmask flags 474 * Return: value of perf event counter read or error code 475 * 476 * int bpf_redirect(ifindex, flags) 477 * redirect to another netdev 478 * @ifindex: ifindex of the net device 479 * @flags: 480 * cls_bpf: 481 * bit 0 - if set, redirect to ingress instead of egress 482 * other bits - reserved 483 * xdp_bpf: 484 * all bits - reserved 485 * Return: cls_bpf: TC_ACT_REDIRECT on success or TC_ACT_SHOT on error 486 * xdp_bfp: XDP_REDIRECT on success or XDP_ABORT on error 487 * int bpf_redirect_map(map, key, flags) 488 * redirect to endpoint in map 489 * @map: pointer to dev map 490 * @key: index in map to lookup 491 * @flags: -- 492 * Return: XDP_REDIRECT on success or XDP_ABORT on error 493 * 494 * u32 bpf_get_route_realm(skb) 495 * retrieve a dst's tclassid 496 * @skb: pointer to skb 497 * Return: realm if != 0 498 * 499 * int bpf_perf_event_output(ctx, map, flags, data, size) 500 * output perf raw sample 501 * @ctx: struct pt_regs* 502 * @map: pointer to perf_event_array map 503 * @flags: index of event in the map or bitmask flags 504 * @data: data on stack to be output as raw data 505 * @size: size of data 506 * Return: 0 on success or negative error 507 * 508 * int bpf_get_stackid(ctx, map, flags) 509 * walk user or kernel stack and return id 510 * @ctx: struct pt_regs* 511 * @map: pointer to stack_trace map 512 * @flags: bits 0-7 - numer of stack frames to skip 513 * bit 8 - collect user stack instead of kernel 514 * bit 9 - compare stacks by hash only 515 * bit 10 - if two different stacks hash into the same stackid 516 * discard old 517 * other bits - reserved 518 * Return: >= 0 stackid on success or negative error 519 * 520 * s64 bpf_csum_diff(from, from_size, to, to_size, seed) 521 * calculate csum diff 522 * @from: raw from buffer 523 * @from_size: length of from buffer 524 * @to: raw to buffer 525 * @to_size: length of to buffer 526 * @seed: optional seed 527 * Return: csum result or negative error code 528 * 529 * int bpf_skb_get_tunnel_opt(skb, opt, size) 530 * retrieve tunnel options metadata 531 * @skb: pointer to skb 532 * @opt: pointer to raw tunnel option data 533 * @size: size of @opt 534 * Return: option size 535 * 536 * int bpf_skb_set_tunnel_opt(skb, opt, size) 537 * populate tunnel options metadata 538 * @skb: pointer to skb 539 * @opt: pointer to raw tunnel option data 540 * @size: size of @opt 541 * Return: 0 on success or negative error 542 * 543 * int bpf_skb_change_proto(skb, proto, flags) 544 * Change protocol of the skb. Currently supported is v4 -> v6, 545 * v6 -> v4 transitions. The helper will also resize the skb. eBPF 546 * program is expected to fill the new headers via skb_store_bytes 547 * and lX_csum_replace. 548 * @skb: pointer to skb 549 * @proto: new skb->protocol type 550 * @flags: reserved 551 * Return: 0 on success or negative error 552 * 553 * int bpf_skb_change_type(skb, type) 554 * Change packet type of skb. 555 * @skb: pointer to skb 556 * @type: new skb->pkt_type type 557 * Return: 0 on success or negative error 558 * 559 * int bpf_skb_under_cgroup(skb, map, index) 560 * Check cgroup2 membership of skb 561 * @skb: pointer to skb 562 * @map: pointer to bpf_map in BPF_MAP_TYPE_CGROUP_ARRAY type 563 * @index: index of the cgroup in the bpf_map 564 * Return: 565 * == 0 skb failed the cgroup2 descendant test 566 * == 1 skb succeeded the cgroup2 descendant test 567 * < 0 error 568 * 569 * u32 bpf_get_hash_recalc(skb) 570 * Retrieve and possibly recalculate skb->hash. 571 * @skb: pointer to skb 572 * Return: hash 573 * 574 * u64 bpf_get_current_task(void) 575 * Returns current task_struct 576 * Return: current 577 * 578 * int bpf_probe_write_user(void *dst, void *src, int len) 579 * safely attempt to write to a location 580 * @dst: destination address in userspace 581 * @src: source address on stack 582 * @len: number of bytes to copy 583 * Return: 0 on success or negative error 584 * 585 * int bpf_current_task_under_cgroup(map, index) 586 * Check cgroup2 membership of current task 587 * @map: pointer to bpf_map in BPF_MAP_TYPE_CGROUP_ARRAY type 588 * @index: index of the cgroup in the bpf_map 589 * Return: 590 * == 0 current failed the cgroup2 descendant test 591 * == 1 current succeeded the cgroup2 descendant test 592 * < 0 error 593 * 594 * int bpf_skb_change_tail(skb, len, flags) 595 * The helper will resize the skb to the given new size, to be used f.e. 596 * with control messages. 597 * @skb: pointer to skb 598 * @len: new skb length 599 * @flags: reserved 600 * Return: 0 on success or negative error 601 * 602 * int bpf_skb_pull_data(skb, len) 603 * The helper will pull in non-linear data in case the skb is non-linear 604 * and not all of len are part of the linear section. Only needed for 605 * read/write with direct packet access. 606 * @skb: pointer to skb 607 * @len: len to make read/writeable 608 * Return: 0 on success or negative error 609 * 610 * s64 bpf_csum_update(skb, csum) 611 * Adds csum into skb->csum in case of CHECKSUM_COMPLETE. 612 * @skb: pointer to skb 613 * @csum: csum to add 614 * Return: csum on success or negative error 615 * 616 * void bpf_set_hash_invalid(skb) 617 * Invalidate current skb->hash. 618 * @skb: pointer to skb 619 * 620 * int bpf_get_numa_node_id() 621 * Return: Id of current NUMA node. 622 * 623 * int bpf_skb_change_head() 624 * Grows headroom of skb and adjusts MAC header offset accordingly. 625 * Will extends/reallocae as required automatically. 626 * May change skb data pointer and will thus invalidate any check 627 * performed for direct packet access. 628 * @skb: pointer to skb 629 * @len: length of header to be pushed in front 630 * @flags: Flags (unused for now) 631 * Return: 0 on success or negative error 632 * 633 * int bpf_xdp_adjust_head(xdp_md, delta) 634 * Adjust the xdp_md.data by delta 635 * @xdp_md: pointer to xdp_md 636 * @delta: An positive/negative integer to be added to xdp_md.data 637 * Return: 0 on success or negative on error 638 * 639 * int bpf_probe_read_str(void *dst, int size, const void *unsafe_ptr) 640 * Copy a NUL terminated string from unsafe address. In case the string 641 * length is smaller than size, the target is not padded with further NUL 642 * bytes. In case the string length is larger than size, just count-1 643 * bytes are copied and the last byte is set to NUL. 644 * @dst: destination address 645 * @size: maximum number of bytes to copy, including the trailing NUL 646 * @unsafe_ptr: unsafe address 647 * Return: 648 * > 0 length of the string including the trailing NUL on success 649 * < 0 error 650 * 651 * u64 bpf_get_socket_cookie(skb) 652 * Get the cookie for the socket stored inside sk_buff. 653 * @skb: pointer to skb 654 * Return: 8 Bytes non-decreasing number on success or 0 if the socket 655 * field is missing inside sk_buff 656 * 657 * u32 bpf_get_socket_uid(skb) 658 * Get the owner uid of the socket stored inside sk_buff. 659 * @skb: pointer to skb 660 * Return: uid of the socket owner on success or overflowuid if failed. 661 * 662 * u32 bpf_set_hash(skb, hash) 663 * Set full skb->hash. 664 * @skb: pointer to skb 665 * @hash: hash to set 666 * 667 * int bpf_setsockopt(bpf_socket, level, optname, optval, optlen) 668 * Calls setsockopt. Not all opts are available, only those with 669 * integer optvals plus TCP_CONGESTION. 670 * Supported levels: SOL_SOCKET and IPPROTO_TCP 671 * @bpf_socket: pointer to bpf_socket 672 * @level: SOL_SOCKET or IPPROTO_TCP 673 * @optname: option name 674 * @optval: pointer to option value 675 * @optlen: length of optval in bytes 676 * Return: 0 or negative error 677 * 678 * int bpf_getsockopt(bpf_socket, level, optname, optval, optlen) 679 * Calls getsockopt. Not all opts are available. 680 * Supported levels: IPPROTO_TCP 681 * @bpf_socket: pointer to bpf_socket 682 * @level: IPPROTO_TCP 683 * @optname: option name 684 * @optval: pointer to option value 685 * @optlen: length of optval in bytes 686 * Return: 0 or negative error 687 * 688 * int bpf_sock_ops_cb_flags_set(bpf_sock_ops, flags) 689 * Set callback flags for sock_ops 690 * @bpf_sock_ops: pointer to bpf_sock_ops_kern struct 691 * @flags: flags value 692 * Return: 0 for no error 693 * -EINVAL if there is no full tcp socket 694 * bits in flags that are not supported by current kernel 695 * 696 * int bpf_skb_adjust_room(skb, len_diff, mode, flags) 697 * Grow or shrink room in sk_buff. 698 * @skb: pointer to skb 699 * @len_diff: (signed) amount of room to grow/shrink 700 * @mode: operation mode (enum bpf_adj_room_mode) 701 * @flags: reserved for future use 702 * Return: 0 on success or negative error code 703 * 704 * int bpf_sk_redirect_map(map, key, flags) 705 * Redirect skb to a sock in map using key as a lookup key for the 706 * sock in map. 707 * @map: pointer to sockmap 708 * @key: key to lookup sock in map 709 * @flags: reserved for future use 710 * Return: SK_PASS 711 * 712 * int bpf_sock_map_update(skops, map, key, flags) 713 * @skops: pointer to bpf_sock_ops 714 * @map: pointer to sockmap to update 715 * @key: key to insert/update sock in map 716 * @flags: same flags as map update elem 717 * 718 * int bpf_xdp_adjust_meta(xdp_md, delta) 719 * Adjust the xdp_md.data_meta by delta 720 * @xdp_md: pointer to xdp_md 721 * @delta: An positive/negative integer to be added to xdp_md.data_meta 722 * Return: 0 on success or negative on error 723 * 724 * int bpf_perf_event_read_value(map, flags, buf, buf_size) 725 * read perf event counter value and perf event enabled/running time 726 * @map: pointer to perf_event_array map 727 * @flags: index of event in the map or bitmask flags 728 * @buf: buf to fill 729 * @buf_size: size of the buf 730 * Return: 0 on success or negative error code 731 * 732 * int bpf_perf_prog_read_value(ctx, buf, buf_size) 733 * read perf prog attached perf event counter and enabled/running time 734 * @ctx: pointer to ctx 735 * @buf: buf to fill 736 * @buf_size: size of the buf 737 * Return : 0 on success or negative error code 738 * 739 * int bpf_override_return(pt_regs, rc) 740 * @pt_regs: pointer to struct pt_regs 741 * @rc: the return value to set 742 * 743 * int bpf_msg_redirect_map(map, key, flags) 744 * Redirect msg to a sock in map using key as a lookup key for the 745 * sock in map. 746 * @map: pointer to sockmap 747 * @key: key to lookup sock in map 748 * @flags: reserved for future use 749 * Return: SK_PASS 750 * 751 * int bpf_bind(ctx, addr, addr_len) 752 * Bind socket to address. Only binding to IP is supported, no port can be 753 * set in addr. 754 * @ctx: pointer to context of type bpf_sock_addr 755 * @addr: pointer to struct sockaddr to bind socket to 756 * @addr_len: length of sockaddr structure 757 * Return: 0 on success or negative error code 758 */ 759 #define __BPF_FUNC_MAPPER(FN) \ 760 FN(unspec), \ 761 FN(map_lookup_elem), \ 762 FN(map_update_elem), \ 763 FN(map_delete_elem), \ 764 FN(probe_read), \ 765 FN(ktime_get_ns), \ 766 FN(trace_printk), \ 767 FN(get_prandom_u32), \ 768 FN(get_smp_processor_id), \ 769 FN(skb_store_bytes), \ 770 FN(l3_csum_replace), \ 771 FN(l4_csum_replace), \ 772 FN(tail_call), \ 773 FN(clone_redirect), \ 774 FN(get_current_pid_tgid), \ 775 FN(get_current_uid_gid), \ 776 FN(get_current_comm), \ 777 FN(get_cgroup_classid), \ 778 FN(skb_vlan_push), \ 779 FN(skb_vlan_pop), \ 780 FN(skb_get_tunnel_key), \ 781 FN(skb_set_tunnel_key), \ 782 FN(perf_event_read), \ 783 FN(redirect), \ 784 FN(get_route_realm), \ 785 FN(perf_event_output), \ 786 FN(skb_load_bytes), \ 787 FN(get_stackid), \ 788 FN(csum_diff), \ 789 FN(skb_get_tunnel_opt), \ 790 FN(skb_set_tunnel_opt), \ 791 FN(skb_change_proto), \ 792 FN(skb_change_type), \ 793 FN(skb_under_cgroup), \ 794 FN(get_hash_recalc), \ 795 FN(get_current_task), \ 796 FN(probe_write_user), \ 797 FN(current_task_under_cgroup), \ 798 FN(skb_change_tail), \ 799 FN(skb_pull_data), \ 800 FN(csum_update), \ 801 FN(set_hash_invalid), \ 802 FN(get_numa_node_id), \ 803 FN(skb_change_head), \ 804 FN(xdp_adjust_head), \ 805 FN(probe_read_str), \ 806 FN(get_socket_cookie), \ 807 FN(get_socket_uid), \ 808 FN(set_hash), \ 809 FN(setsockopt), \ 810 FN(skb_adjust_room), \ 811 FN(redirect_map), \ 812 FN(sk_redirect_map), \ 813 FN(sock_map_update), \ 814 FN(xdp_adjust_meta), \ 815 FN(perf_event_read_value), \ 816 FN(perf_prog_read_value), \ 817 FN(getsockopt), \ 818 FN(override_return), \ 819 FN(sock_ops_cb_flags_set), \ 820 FN(msg_redirect_map), \ 821 FN(msg_apply_bytes), \ 822 FN(msg_cork_bytes), \ 823 FN(msg_pull_data), \ 824 FN(bind), 825 826 /* integer value in 'imm' field of BPF_CALL instruction selects which helper 827 * function eBPF program intends to call 828 */ 829 #define __BPF_ENUM_FN(x) BPF_FUNC_ ## x 830 enum bpf_func_id { 831 __BPF_FUNC_MAPPER(__BPF_ENUM_FN) 832 __BPF_FUNC_MAX_ID, 833 }; 834 #undef __BPF_ENUM_FN 835 836 /* All flags used by eBPF helper functions, placed here. */ 837 838 /* BPF_FUNC_skb_store_bytes flags. */ 839 #define BPF_F_RECOMPUTE_CSUM (1ULL << 0) 840 #define BPF_F_INVALIDATE_HASH (1ULL << 1) 841 842 /* BPF_FUNC_l3_csum_replace and BPF_FUNC_l4_csum_replace flags. 843 * First 4 bits are for passing the header field size. 844 */ 845 #define BPF_F_HDR_FIELD_MASK 0xfULL 846 847 /* BPF_FUNC_l4_csum_replace flags. */ 848 #define BPF_F_PSEUDO_HDR (1ULL << 4) 849 #define BPF_F_MARK_MANGLED_0 (1ULL << 5) 850 #define BPF_F_MARK_ENFORCE (1ULL << 6) 851 852 /* BPF_FUNC_clone_redirect and BPF_FUNC_redirect flags. */ 853 #define BPF_F_INGRESS (1ULL << 0) 854 855 /* BPF_FUNC_skb_set_tunnel_key and BPF_FUNC_skb_get_tunnel_key flags. */ 856 #define BPF_F_TUNINFO_IPV6 (1ULL << 0) 857 858 /* BPF_FUNC_get_stackid flags. */ 859 #define BPF_F_SKIP_FIELD_MASK 0xffULL 860 #define BPF_F_USER_STACK (1ULL << 8) 861 #define BPF_F_FAST_STACK_CMP (1ULL << 9) 862 #define BPF_F_REUSE_STACKID (1ULL << 10) 863 864 /* BPF_FUNC_skb_set_tunnel_key flags. */ 865 #define BPF_F_ZERO_CSUM_TX (1ULL << 1) 866 #define BPF_F_DONT_FRAGMENT (1ULL << 2) 867 868 /* BPF_FUNC_perf_event_output, BPF_FUNC_perf_event_read and 869 * BPF_FUNC_perf_event_read_value flags. 870 */ 871 #define BPF_F_INDEX_MASK 0xffffffffULL 872 #define BPF_F_CURRENT_CPU BPF_F_INDEX_MASK 873 /* BPF_FUNC_perf_event_output for sk_buff input context. */ 874 #define BPF_F_CTXLEN_MASK (0xfffffULL << 32) 875 876 /* Mode for BPF_FUNC_skb_adjust_room helper. */ 877 enum bpf_adj_room_mode { 878 BPF_ADJ_ROOM_NET, 879 }; 880 881 /* user accessible mirror of in-kernel sk_buff. 882 * new fields can only be added to the end of this structure 883 */ 884 struct __sk_buff { 885 __u32 len; 886 __u32 pkt_type; 887 __u32 mark; 888 __u32 queue_mapping; 889 __u32 protocol; 890 __u32 vlan_present; 891 __u32 vlan_tci; 892 __u32 vlan_proto; 893 __u32 priority; 894 __u32 ingress_ifindex; 895 __u32 ifindex; 896 __u32 tc_index; 897 __u32 cb[5]; 898 __u32 hash; 899 __u32 tc_classid; 900 __u32 data; 901 __u32 data_end; 902 __u32 napi_id; 903 904 /* Accessed by BPF_PROG_TYPE_sk_skb types from here to ... */ 905 __u32 family; 906 __u32 remote_ip4; /* Stored in network byte order */ 907 __u32 local_ip4; /* Stored in network byte order */ 908 __u32 remote_ip6[4]; /* Stored in network byte order */ 909 __u32 local_ip6[4]; /* Stored in network byte order */ 910 __u32 remote_port; /* Stored in network byte order */ 911 __u32 local_port; /* stored in host byte order */ 912 /* ... here. */ 913 914 __u32 data_meta; 915 }; 916 917 struct bpf_tunnel_key { 918 __u32 tunnel_id; 919 union { 920 __u32 remote_ipv4; 921 __u32 remote_ipv6[4]; 922 }; 923 __u8 tunnel_tos; 924 __u8 tunnel_ttl; 925 __u16 tunnel_ext; 926 __u32 tunnel_label; 927 }; 928 929 /* Generic BPF return codes which all BPF program types may support. 930 * The values are binary compatible with their TC_ACT_* counter-part to 931 * provide backwards compatibility with existing SCHED_CLS and SCHED_ACT 932 * programs. 933 * 934 * XDP is handled seprately, see XDP_*. 935 */ 936 enum bpf_ret_code { 937 BPF_OK = 0, 938 /* 1 reserved */ 939 BPF_DROP = 2, 940 /* 3-6 reserved */ 941 BPF_REDIRECT = 7, 942 /* >127 are reserved for prog type specific return codes */ 943 }; 944 945 struct bpf_sock { 946 __u32 bound_dev_if; 947 __u32 family; 948 __u32 type; 949 __u32 protocol; 950 __u32 mark; 951 __u32 priority; 952 __u32 src_ip4; /* Allows 1,2,4-byte read. 953 * Stored in network byte order. 954 */ 955 __u32 src_ip6[4]; /* Allows 1,2,4-byte read. 956 * Stored in network byte order. 957 */ 958 __u32 src_port; /* Allows 4-byte read. 959 * Stored in host byte order 960 */ 961 }; 962 963 #define XDP_PACKET_HEADROOM 256 964 965 /* User return codes for XDP prog type. 966 * A valid XDP program must return one of these defined values. All other 967 * return codes are reserved for future use. Unknown return codes will 968 * result in packet drops and a warning via bpf_warn_invalid_xdp_action(). 969 */ 970 enum xdp_action { 971 XDP_ABORTED = 0, 972 XDP_DROP, 973 XDP_PASS, 974 XDP_TX, 975 XDP_REDIRECT, 976 }; 977 978 /* user accessible metadata for XDP packet hook 979 * new fields must be added to the end of this structure 980 */ 981 struct xdp_md { 982 __u32 data; 983 __u32 data_end; 984 __u32 data_meta; 985 /* Below access go through struct xdp_rxq_info */ 986 __u32 ingress_ifindex; /* rxq->dev->ifindex */ 987 __u32 rx_queue_index; /* rxq->queue_index */ 988 }; 989 990 enum sk_action { 991 SK_DROP = 0, 992 SK_PASS, 993 }; 994 995 /* user accessible metadata for SK_MSG packet hook, new fields must 996 * be added to the end of this structure 997 */ 998 struct sk_msg_md { 999 void *data; 1000 void *data_end; 1001 }; 1002 1003 #define BPF_TAG_SIZE 8 1004 1005 struct bpf_prog_info { 1006 __u32 type; 1007 __u32 id; 1008 __u8 tag[BPF_TAG_SIZE]; 1009 __u32 jited_prog_len; 1010 __u32 xlated_prog_len; 1011 __aligned_u64 jited_prog_insns; 1012 __aligned_u64 xlated_prog_insns; 1013 __u64 load_time; /* ns since boottime */ 1014 __u32 created_by_uid; 1015 __u32 nr_map_ids; 1016 __aligned_u64 map_ids; 1017 char name[BPF_OBJ_NAME_LEN]; 1018 __u32 ifindex; 1019 __u64 netns_dev; 1020 __u64 netns_ino; 1021 } __attribute__((aligned(8))); 1022 1023 struct bpf_map_info { 1024 __u32 type; 1025 __u32 id; 1026 __u32 key_size; 1027 __u32 value_size; 1028 __u32 max_entries; 1029 __u32 map_flags; 1030 char name[BPF_OBJ_NAME_LEN]; 1031 __u32 ifindex; 1032 __u64 netns_dev; 1033 __u64 netns_ino; 1034 } __attribute__((aligned(8))); 1035 1036 /* User bpf_sock_addr struct to access socket fields and sockaddr struct passed 1037 * by user and intended to be used by socket (e.g. to bind to, depends on 1038 * attach attach type). 1039 */ 1040 struct bpf_sock_addr { 1041 __u32 user_family; /* Allows 4-byte read, but no write. */ 1042 __u32 user_ip4; /* Allows 1,2,4-byte read and 4-byte write. 1043 * Stored in network byte order. 1044 */ 1045 __u32 user_ip6[4]; /* Allows 1,2,4-byte read an 4-byte write. 1046 * Stored in network byte order. 1047 */ 1048 __u32 user_port; /* Allows 4-byte read and write. 1049 * Stored in network byte order 1050 */ 1051 __u32 family; /* Allows 4-byte read, but no write */ 1052 __u32 type; /* Allows 4-byte read, but no write */ 1053 __u32 protocol; /* Allows 4-byte read, but no write */ 1054 }; 1055 1056 /* User bpf_sock_ops struct to access socket values and specify request ops 1057 * and their replies. 1058 * Some of this fields are in network (bigendian) byte order and may need 1059 * to be converted before use (bpf_ntohl() defined in samples/bpf/bpf_endian.h). 1060 * New fields can only be added at the end of this structure 1061 */ 1062 struct bpf_sock_ops { 1063 __u32 op; 1064 union { 1065 __u32 args[4]; /* Optionally passed to bpf program */ 1066 __u32 reply; /* Returned by bpf program */ 1067 __u32 replylong[4]; /* Optionally returned by bpf prog */ 1068 }; 1069 __u32 family; 1070 __u32 remote_ip4; /* Stored in network byte order */ 1071 __u32 local_ip4; /* Stored in network byte order */ 1072 __u32 remote_ip6[4]; /* Stored in network byte order */ 1073 __u32 local_ip6[4]; /* Stored in network byte order */ 1074 __u32 remote_port; /* Stored in network byte order */ 1075 __u32 local_port; /* stored in host byte order */ 1076 __u32 is_fullsock; /* Some TCP fields are only valid if 1077 * there is a full socket. If not, the 1078 * fields read as zero. 1079 */ 1080 __u32 snd_cwnd; 1081 __u32 srtt_us; /* Averaged RTT << 3 in usecs */ 1082 __u32 bpf_sock_ops_cb_flags; /* flags defined in uapi/linux/tcp.h */ 1083 __u32 state; 1084 __u32 rtt_min; 1085 __u32 snd_ssthresh; 1086 __u32 rcv_nxt; 1087 __u32 snd_nxt; 1088 __u32 snd_una; 1089 __u32 mss_cache; 1090 __u32 ecn_flags; 1091 __u32 rate_delivered; 1092 __u32 rate_interval_us; 1093 __u32 packets_out; 1094 __u32 retrans_out; 1095 __u32 total_retrans; 1096 __u32 segs_in; 1097 __u32 data_segs_in; 1098 __u32 segs_out; 1099 __u32 data_segs_out; 1100 __u32 lost_out; 1101 __u32 sacked_out; 1102 __u32 sk_txhash; 1103 __u64 bytes_received; 1104 __u64 bytes_acked; 1105 }; 1106 1107 /* Definitions for bpf_sock_ops_cb_flags */ 1108 #define BPF_SOCK_OPS_RTO_CB_FLAG (1<<0) 1109 #define BPF_SOCK_OPS_RETRANS_CB_FLAG (1<<1) 1110 #define BPF_SOCK_OPS_STATE_CB_FLAG (1<<2) 1111 #define BPF_SOCK_OPS_ALL_CB_FLAGS 0x7 /* Mask of all currently 1112 * supported cb flags 1113 */ 1114 1115 /* List of known BPF sock_ops operators. 1116 * New entries can only be added at the end 1117 */ 1118 enum { 1119 BPF_SOCK_OPS_VOID, 1120 BPF_SOCK_OPS_TIMEOUT_INIT, /* Should return SYN-RTO value to use or 1121 * -1 if default value should be used 1122 */ 1123 BPF_SOCK_OPS_RWND_INIT, /* Should return initial advertized 1124 * window (in packets) or -1 if default 1125 * value should be used 1126 */ 1127 BPF_SOCK_OPS_TCP_CONNECT_CB, /* Calls BPF program right before an 1128 * active connection is initialized 1129 */ 1130 BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB, /* Calls BPF program when an 1131 * active connection is 1132 * established 1133 */ 1134 BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB, /* Calls BPF program when a 1135 * passive connection is 1136 * established 1137 */ 1138 BPF_SOCK_OPS_NEEDS_ECN, /* If connection's congestion control 1139 * needs ECN 1140 */ 1141 BPF_SOCK_OPS_BASE_RTT, /* Get base RTT. The correct value is 1142 * based on the path and may be 1143 * dependent on the congestion control 1144 * algorithm. In general it indicates 1145 * a congestion threshold. RTTs above 1146 * this indicate congestion 1147 */ 1148 BPF_SOCK_OPS_RTO_CB, /* Called when an RTO has triggered. 1149 * Arg1: value of icsk_retransmits 1150 * Arg2: value of icsk_rto 1151 * Arg3: whether RTO has expired 1152 */ 1153 BPF_SOCK_OPS_RETRANS_CB, /* Called when skb is retransmitted. 1154 * Arg1: sequence number of 1st byte 1155 * Arg2: # segments 1156 * Arg3: return value of 1157 * tcp_transmit_skb (0 => success) 1158 */ 1159 BPF_SOCK_OPS_STATE_CB, /* Called when TCP changes state. 1160 * Arg1: old_state 1161 * Arg2: new_state 1162 */ 1163 }; 1164 1165 /* List of TCP states. There is a build check in net/ipv4/tcp.c to detect 1166 * changes between the TCP and BPF versions. Ideally this should never happen. 1167 * If it does, we need to add code to convert them before calling 1168 * the BPF sock_ops function. 1169 */ 1170 enum { 1171 BPF_TCP_ESTABLISHED = 1, 1172 BPF_TCP_SYN_SENT, 1173 BPF_TCP_SYN_RECV, 1174 BPF_TCP_FIN_WAIT1, 1175 BPF_TCP_FIN_WAIT2, 1176 BPF_TCP_TIME_WAIT, 1177 BPF_TCP_CLOSE, 1178 BPF_TCP_CLOSE_WAIT, 1179 BPF_TCP_LAST_ACK, 1180 BPF_TCP_LISTEN, 1181 BPF_TCP_CLOSING, /* Now a valid state */ 1182 BPF_TCP_NEW_SYN_RECV, 1183 1184 BPF_TCP_MAX_STATES /* Leave at the end! */ 1185 }; 1186 1187 #define TCP_BPF_IW 1001 /* Set TCP initial congestion window */ 1188 #define TCP_BPF_SNDCWND_CLAMP 1002 /* Set sndcwnd_clamp */ 1189 1190 struct bpf_perf_event_value { 1191 __u64 counter; 1192 __u64 enabled; 1193 __u64 running; 1194 }; 1195 1196 #define BPF_DEVCG_ACC_MKNOD (1ULL << 0) 1197 #define BPF_DEVCG_ACC_READ (1ULL << 1) 1198 #define BPF_DEVCG_ACC_WRITE (1ULL << 2) 1199 1200 #define BPF_DEVCG_DEV_BLOCK (1ULL << 0) 1201 #define BPF_DEVCG_DEV_CHAR (1ULL << 1) 1202 1203 struct bpf_cgroup_dev_ctx { 1204 /* access_type encoded as (BPF_DEVCG_ACC_* << 16) | BPF_DEVCG_DEV_* */ 1205 __u32 access_type; 1206 __u32 major; 1207 __u32 minor; 1208 }; 1209 1210 struct bpf_raw_tracepoint_args { 1211 __u64 args[0]; 1212 }; 1213 1214 #endif /* _UAPI__LINUX_BPF_H__ */ 1215