tools/headers: Synchronize kernel ABI headers
After the SPDX license tags were added a number of tooling headers got out of
sync with their kernel variants, generating lots of build warnings.
Sync them:
- tools/arch/x86/include/asm/disabled-features.h,
tools/arch/x86/include/asm/required-features.h,
tools/include/linux/hash.h:
Remove the SPDX tag where the kernel version does not have it.
- tools/include/asm-generic/bitops/__fls.h,
tools/include/asm-generic/bitops/arch_hweight.h,
tools/include/asm-generic/bitops/const_hweight.h,
tools/include/asm-generic/bitops/fls.h,
tools/include/asm-generic/bitops/fls64.h,
tools/include/uapi/asm-generic/ioctls.h,
tools/include/uapi/asm-generic/mman-common.h,
tools/include/uapi/sound/asound.h,
tools/include/uapi/linux/kvm.h,
tools/include/uapi/linux/perf_event.h,
tools/include/uapi/linux/sched.h,
tools/include/uapi/linux/vhost.h,
tools/include/uapi/sound/asound.h:
Add the SPDX tag of the respective kernel header.
- tools/include/uapi/linux/bpf_common.h,
tools/include/uapi/linux/fcntl.h,
tools/include/uapi/linux/hw_breakpoint.h,
tools/include/uapi/linux/mman.h,
tools/include/uapi/linux/stat.h,
Change the tag to the kernel header version:
-/* SPDX-License-Identifier: GPL-2.0 */
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
Also sync other header details:
- include/uapi/sound/asound.h:
Fix pointless end of line whitespace noise the header grew in this cycle.
- tools/arch/x86/lib/memcpy_64.S:
Sync the code and add tools/include/asm/export.h with dummy wrappers
to support building the kernel side code in a tooling header environment.
- tools/include/uapi/asm-generic/mman.h,
tools/include/uapi/linux/bpf.h:
Sync other details that don't impact tooling's use of the ABIs.
Acked-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: linux-kernel@vger.kernel.org
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-11-03 11:18:37 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
2016-07-11 19:38:05 +00:00
|
|
|
/* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of version 2 of the GNU General Public
|
|
|
|
|
* License as published by the Free Software Foundation.
|
|
|
|
|
*/
|
|
|
|
|
#ifndef _UAPI__LINUX_BPF_H__
|
|
|
|
|
#define _UAPI__LINUX_BPF_H__
|
|
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
|
#include <linux/bpf_common.h>
|
|
|
|
|
|
|
|
|
|
/* Extended instruction set based on top of classic BPF */
|
|
|
|
|
|
|
|
|
|
/* instruction classes */
|
|
|
|
|
#define BPF_ALU64 0x07 /* alu mode in double word width */
|
|
|
|
|
|
|
|
|
|
/* ld/ldx fields */
|
2018-01-26 00:14:16 +00:00
|
|
|
#define BPF_DW 0x18 /* double word (64-bit) */
|
2016-07-11 19:38:05 +00:00
|
|
|
#define BPF_XADD 0xc0 /* exclusive add */
|
|
|
|
|
|
|
|
|
|
/* alu/jmp fields */
|
|
|
|
|
#define BPF_MOV 0xb0 /* mov reg to reg */
|
|
|
|
|
#define BPF_ARSH 0xc0 /* sign extending arithmetic shift right */
|
|
|
|
|
|
|
|
|
|
/* change endianness of a register */
|
|
|
|
|
#define BPF_END 0xd0 /* flags for endianness conversion: */
|
|
|
|
|
#define BPF_TO_LE 0x00 /* convert to little-endian */
|
|
|
|
|
#define BPF_TO_BE 0x08 /* convert to big-endian */
|
|
|
|
|
#define BPF_FROM_LE BPF_TO_LE
|
|
|
|
|
#define BPF_FROM_BE BPF_TO_BE
|
|
|
|
|
|
bpf: add BPF_J{LT,LE,SLT,SLE} instructions
Currently, eBPF only understands BPF_JGT (>), BPF_JGE (>=),
BPF_JSGT (s>), BPF_JSGE (s>=) instructions, this means that
particularly *JLT/*JLE counterparts involving immediates need
to be rewritten from e.g. X < [IMM] by swapping arguments into
[IMM] > X, meaning the immediate first is required to be loaded
into a register Y := [IMM], such that then we can compare with
Y > X. Note that the destination operand is always required to
be a register.
This has the downside of having unnecessarily increased register
pressure, meaning complex program would need to spill other
registers temporarily to stack in order to obtain an unused
register for the [IMM]. Loading to registers will thus also
affect state pruning since we need to account for that register
use and potentially those registers that had to be spilled/filled
again. As a consequence slightly more stack space might have
been used due to spilling, and BPF programs are a bit longer
due to extra code involving the register load and potentially
required spill/fills.
Thus, add BPF_JLT (<), BPF_JLE (<=), BPF_JSLT (s<), BPF_JSLE (s<=)
counterparts to the eBPF instruction set. Modifying LLVM to
remove the NegateCC() workaround in a PoC patch at [1] and
allowing it to also emit the new instructions resulted in
cilium's BPF programs that are injected into the fast-path to
have a reduced program length in the range of 2-3% (e.g.
accumulated main and tail call sections from one of the object
file reduced from 4864 to 4729 insns), reduced complexity in
the range of 10-30% (e.g. accumulated sections reduced in one
of the cases from 116432 to 88428 insns), and reduced stack
usage in the range of 1-5% (e.g. accumulated sections from one
of the object files reduced from 824 to 784b).
The modification for LLVM will be incorporated in a backwards
compatible way. Plan is for LLVM to have i) a target specific
option to offer a possibility to explicitly enable the extension
by the user (as we have with -m target specific extensions today
for various CPU insns), and ii) have the kernel checked for
presence of the extensions and enable them transparently when
the user is selecting more aggressive options such as -march=native
in a bpf target context. (Other frontends generating BPF byte
code, e.g. ply can probe the kernel directly for its code
generation.)
[1] https://github.com/borkmann/llvm/tree/bpf-insns
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Acked-by: Alexei Starovoitov <ast@kernel.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-09 23:39:55 +00:00
|
|
|
/* jmp encodings */
|
2016-07-11 19:38:05 +00:00
|
|
|
#define BPF_JNE 0x50 /* jump != */
|
bpf: add BPF_J{LT,LE,SLT,SLE} instructions
Currently, eBPF only understands BPF_JGT (>), BPF_JGE (>=),
BPF_JSGT (s>), BPF_JSGE (s>=) instructions, this means that
particularly *JLT/*JLE counterparts involving immediates need
to be rewritten from e.g. X < [IMM] by swapping arguments into
[IMM] > X, meaning the immediate first is required to be loaded
into a register Y := [IMM], such that then we can compare with
Y > X. Note that the destination operand is always required to
be a register.
This has the downside of having unnecessarily increased register
pressure, meaning complex program would need to spill other
registers temporarily to stack in order to obtain an unused
register for the [IMM]. Loading to registers will thus also
affect state pruning since we need to account for that register
use and potentially those registers that had to be spilled/filled
again. As a consequence slightly more stack space might have
been used due to spilling, and BPF programs are a bit longer
due to extra code involving the register load and potentially
required spill/fills.
Thus, add BPF_JLT (<), BPF_JLE (<=), BPF_JSLT (s<), BPF_JSLE (s<=)
counterparts to the eBPF instruction set. Modifying LLVM to
remove the NegateCC() workaround in a PoC patch at [1] and
allowing it to also emit the new instructions resulted in
cilium's BPF programs that are injected into the fast-path to
have a reduced program length in the range of 2-3% (e.g.
accumulated main and tail call sections from one of the object
file reduced from 4864 to 4729 insns), reduced complexity in
the range of 10-30% (e.g. accumulated sections reduced in one
of the cases from 116432 to 88428 insns), and reduced stack
usage in the range of 1-5% (e.g. accumulated sections from one
of the object files reduced from 824 to 784b).
The modification for LLVM will be incorporated in a backwards
compatible way. Plan is for LLVM to have i) a target specific
option to offer a possibility to explicitly enable the extension
by the user (as we have with -m target specific extensions today
for various CPU insns), and ii) have the kernel checked for
presence of the extensions and enable them transparently when
the user is selecting more aggressive options such as -march=native
in a bpf target context. (Other frontends generating BPF byte
code, e.g. ply can probe the kernel directly for its code
generation.)
[1] https://github.com/borkmann/llvm/tree/bpf-insns
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Acked-by: Alexei Starovoitov <ast@kernel.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-09 23:39:55 +00:00
|
|
|
#define BPF_JLT 0xa0 /* LT is unsigned, '<' */
|
|
|
|
|
#define BPF_JLE 0xb0 /* LE is unsigned, '<=' */
|
2016-07-11 19:38:05 +00:00
|
|
|
#define BPF_JSGT 0x60 /* SGT is signed '>', GT in x86 */
|
|
|
|
|
#define BPF_JSGE 0x70 /* SGE is signed '>=', GE in x86 */
|
bpf: add BPF_J{LT,LE,SLT,SLE} instructions
Currently, eBPF only understands BPF_JGT (>), BPF_JGE (>=),
BPF_JSGT (s>), BPF_JSGE (s>=) instructions, this means that
particularly *JLT/*JLE counterparts involving immediates need
to be rewritten from e.g. X < [IMM] by swapping arguments into
[IMM] > X, meaning the immediate first is required to be loaded
into a register Y := [IMM], such that then we can compare with
Y > X. Note that the destination operand is always required to
be a register.
This has the downside of having unnecessarily increased register
pressure, meaning complex program would need to spill other
registers temporarily to stack in order to obtain an unused
register for the [IMM]. Loading to registers will thus also
affect state pruning since we need to account for that register
use and potentially those registers that had to be spilled/filled
again. As a consequence slightly more stack space might have
been used due to spilling, and BPF programs are a bit longer
due to extra code involving the register load and potentially
required spill/fills.
Thus, add BPF_JLT (<), BPF_JLE (<=), BPF_JSLT (s<), BPF_JSLE (s<=)
counterparts to the eBPF instruction set. Modifying LLVM to
remove the NegateCC() workaround in a PoC patch at [1] and
allowing it to also emit the new instructions resulted in
cilium's BPF programs that are injected into the fast-path to
have a reduced program length in the range of 2-3% (e.g.
accumulated main and tail call sections from one of the object
file reduced from 4864 to 4729 insns), reduced complexity in
the range of 10-30% (e.g. accumulated sections reduced in one
of the cases from 116432 to 88428 insns), and reduced stack
usage in the range of 1-5% (e.g. accumulated sections from one
of the object files reduced from 824 to 784b).
The modification for LLVM will be incorporated in a backwards
compatible way. Plan is for LLVM to have i) a target specific
option to offer a possibility to explicitly enable the extension
by the user (as we have with -m target specific extensions today
for various CPU insns), and ii) have the kernel checked for
presence of the extensions and enable them transparently when
the user is selecting more aggressive options such as -march=native
in a bpf target context. (Other frontends generating BPF byte
code, e.g. ply can probe the kernel directly for its code
generation.)
[1] https://github.com/borkmann/llvm/tree/bpf-insns
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Acked-by: Alexei Starovoitov <ast@kernel.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-08-09 23:39:55 +00:00
|
|
|
#define BPF_JSLT 0xc0 /* SLT is signed, '<' */
|
|
|
|
|
#define BPF_JSLE 0xd0 /* SLE is signed, '<=' */
|
2016-07-11 19:38:05 +00:00
|
|
|
#define BPF_CALL 0x80 /* function call */
|
|
|
|
|
#define BPF_EXIT 0x90 /* function return */
|
|
|
|
|
|
|
|
|
|
/* Register numbers */
|
|
|
|
|
enum {
|
|
|
|
|
BPF_REG_0 = 0,
|
|
|
|
|
BPF_REG_1,
|
|
|
|
|
BPF_REG_2,
|
|
|
|
|
BPF_REG_3,
|
|
|
|
|
BPF_REG_4,
|
|
|
|
|
BPF_REG_5,
|
|
|
|
|
BPF_REG_6,
|
|
|
|
|
BPF_REG_7,
|
|
|
|
|
BPF_REG_8,
|
|
|
|
|
BPF_REG_9,
|
|
|
|
|
BPF_REG_10,
|
|
|
|
|
__MAX_BPF_REG,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* BPF has 10 general purpose 64-bit registers and stack frame. */
|
|
|
|
|
#define MAX_BPF_REG __MAX_BPF_REG
|
|
|
|
|
|
|
|
|
|
struct bpf_insn {
|
|
|
|
|
__u8 code; /* opcode */
|
|
|
|
|
__u8 dst_reg:4; /* dest register */
|
|
|
|
|
__u8 src_reg:4; /* source register */
|
|
|
|
|
__s16 off; /* signed offset */
|
|
|
|
|
__s32 imm; /* signed immediate constant */
|
|
|
|
|
};
|
|
|
|
|
|
2017-02-09 23:21:35 +00:00
|
|
|
/* Key of an a BPF_MAP_TYPE_LPM_TRIE entry */
|
|
|
|
|
struct bpf_lpm_trie_key {
|
|
|
|
|
__u32 prefixlen; /* up to 32 for AF_INET, 128 for AF_INET6 */
|
|
|
|
|
__u8 data[0]; /* Arbitrary size */
|
|
|
|
|
};
|
|
|
|
|
|
2016-07-11 19:38:05 +00:00
|
|
|
/* BPF syscall commands, see bpf(2) man-page for details. */
|
|
|
|
|
enum bpf_cmd {
|
|
|
|
|
BPF_MAP_CREATE,
|
|
|
|
|
BPF_MAP_LOOKUP_ELEM,
|
|
|
|
|
BPF_MAP_UPDATE_ELEM,
|
|
|
|
|
BPF_MAP_DELETE_ELEM,
|
|
|
|
|
BPF_MAP_GET_NEXT_KEY,
|
|
|
|
|
BPF_PROG_LOAD,
|
|
|
|
|
BPF_OBJ_PIN,
|
|
|
|
|
BPF_OBJ_GET,
|
2016-12-09 02:46:14 +00:00
|
|
|
BPF_PROG_ATTACH,
|
|
|
|
|
BPF_PROG_DETACH,
|
2017-03-31 04:45:39 +00:00
|
|
|
BPF_PROG_TEST_RUN,
|
2017-06-05 19:15:53 +00:00
|
|
|
BPF_PROG_GET_NEXT_ID,
|
|
|
|
|
BPF_MAP_GET_NEXT_ID,
|
|
|
|
|
BPF_PROG_GET_FD_BY_ID,
|
|
|
|
|
BPF_MAP_GET_FD_BY_ID,
|
|
|
|
|
BPF_OBJ_GET_INFO_BY_FD,
|
2017-10-03 05:50:26 +00:00
|
|
|
BPF_PROG_QUERY,
|
2016-07-11 19:38:05 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum bpf_map_type {
|
|
|
|
|
BPF_MAP_TYPE_UNSPEC,
|
|
|
|
|
BPF_MAP_TYPE_HASH,
|
|
|
|
|
BPF_MAP_TYPE_ARRAY,
|
|
|
|
|
BPF_MAP_TYPE_PROG_ARRAY,
|
|
|
|
|
BPF_MAP_TYPE_PERF_EVENT_ARRAY,
|
|
|
|
|
BPF_MAP_TYPE_PERCPU_HASH,
|
|
|
|
|
BPF_MAP_TYPE_PERCPU_ARRAY,
|
|
|
|
|
BPF_MAP_TYPE_STACK_TRACE,
|
toops: Sync tools/include/uapi/linux/bpf.h with the kernel
The way we're using kernel headers in tools/ now, with a copy that is
made to the same path prefixed by "tools/" plus checking if that copy
got stale, i.e. if the kernel counterpart changed, helps in keeping
track with new features that may be useful for tools to exploit.
For instance, looking at all the changes to bpf.h since it was last
copied to tools/include brings this to toolers' attention:
Need to investigate this one to check how to run a program via perf, setting up
a BPF event, that will take advantage of the way perf already calls clang/LLVM,
sets up the event and runs the workload in a single command line, helping in
debugging such semi cooperative programs:
96ae52279594 ("bpf: Add bpf_probe_write_user BPF helper to be called in tracers")
This one needs further investigation about using the feature it improves
in 'perf trace' to do some tcpdumpin' mixed with syscalls, tracepoints,
probe points, callgraphs, etc:
555c8a8623a3 ("bpf: avoid stack copy and use skb ctx for event output")
Add tracing just packets that are related to some container to that mix:
4a482f34afcc ("cgroup: bpf: Add bpf_skb_in_cgroup_proto")
4ed8ec521ed5 ("cgroup: bpf: Add BPF_MAP_TYPE_CGROUP_ARRAY")
Definetely needs to have example programs accessing task_struct from a bpf proggie
started from 'perf trace':
606274c5abd8 ("bpf: introduce bpf_get_current_task() helper")
Core networking related, XDP:
6ce96ca348a9 ("bpf: add XDP_TX xdp_action for direct forwarding")
6a773a15a1e8 ("bpf: add XDP prog type for early driver filter")
13c5c240f789 ("bpf: add bpf_get_hash_recalc helper")
d2485c4242a8 ("bpf: add bpf_skb_change_type helper")
6578171a7ff0 ("bpf: add bpf_skb_change_proto helper")
Changes detected by the tools build system:
$ make -C tools/perf O=/tmp/build/perf install-bin
make: Entering directory '/home/acme/git/linux/tools/perf'
BUILD: Doing 'make -j4' parallel build
Warning: tools/include/uapi/linux/bpf.h differs from kernel
INSTALL GTK UI
CC /tmp/build/perf/bench/mem-memcpy-x86-64-asm.o
<SNIP>
$
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexei Starovoitov <ast@fb.com>
Cc: Brenden Blanco <bblanco@plumgrid.com>
Cc: Daniel Borkmann <daniel@iogearbox.net>
Cc: David Ahern <dsahern@gmail.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Martin KaFai Lau <kafai@fb.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Sargun Dhillon <sargun@sargun.me>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/n/tip-difq4ts1xvww6eyfs9e7zlft@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-08-09 14:48:07 +00:00
|
|
|
BPF_MAP_TYPE_CGROUP_ARRAY,
|
2016-12-09 02:46:14 +00:00
|
|
|
BPF_MAP_TYPE_LRU_HASH,
|
|
|
|
|
BPF_MAP_TYPE_LRU_PERCPU_HASH,
|
2017-02-09 23:21:35 +00:00
|
|
|
BPF_MAP_TYPE_LPM_TRIE,
|
2017-03-22 17:00:35 +00:00
|
|
|
BPF_MAP_TYPE_ARRAY_OF_MAPS,
|
|
|
|
|
BPF_MAP_TYPE_HASH_OF_MAPS,
|
2017-07-27 00:32:07 +00:00
|
|
|
BPF_MAP_TYPE_DEVMAP,
|
2017-08-16 05:33:32 +00:00
|
|
|
BPF_MAP_TYPE_SOCKMAP,
|
2017-10-16 10:19:28 +00:00
|
|
|
BPF_MAP_TYPE_CPUMAP,
|
2016-07-11 19:38:05 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum bpf_prog_type {
|
|
|
|
|
BPF_PROG_TYPE_UNSPEC,
|
|
|
|
|
BPF_PROG_TYPE_SOCKET_FILTER,
|
|
|
|
|
BPF_PROG_TYPE_KPROBE,
|
|
|
|
|
BPF_PROG_TYPE_SCHED_CLS,
|
|
|
|
|
BPF_PROG_TYPE_SCHED_ACT,
|
|
|
|
|
BPF_PROG_TYPE_TRACEPOINT,
|
toops: Sync tools/include/uapi/linux/bpf.h with the kernel
The way we're using kernel headers in tools/ now, with a copy that is
made to the same path prefixed by "tools/" plus checking if that copy
got stale, i.e. if the kernel counterpart changed, helps in keeping
track with new features that may be useful for tools to exploit.
For instance, looking at all the changes to bpf.h since it was last
copied to tools/include brings this to toolers' attention:
Need to investigate this one to check how to run a program via perf, setting up
a BPF event, that will take advantage of the way perf already calls clang/LLVM,
sets up the event and runs the workload in a single command line, helping in
debugging such semi cooperative programs:
96ae52279594 ("bpf: Add bpf_probe_write_user BPF helper to be called in tracers")
This one needs further investigation about using the feature it improves
in 'perf trace' to do some tcpdumpin' mixed with syscalls, tracepoints,
probe points, callgraphs, etc:
555c8a8623a3 ("bpf: avoid stack copy and use skb ctx for event output")
Add tracing just packets that are related to some container to that mix:
4a482f34afcc ("cgroup: bpf: Add bpf_skb_in_cgroup_proto")
4ed8ec521ed5 ("cgroup: bpf: Add BPF_MAP_TYPE_CGROUP_ARRAY")
Definetely needs to have example programs accessing task_struct from a bpf proggie
started from 'perf trace':
606274c5abd8 ("bpf: introduce bpf_get_current_task() helper")
Core networking related, XDP:
6ce96ca348a9 ("bpf: add XDP_TX xdp_action for direct forwarding")
6a773a15a1e8 ("bpf: add XDP prog type for early driver filter")
13c5c240f789 ("bpf: add bpf_get_hash_recalc helper")
d2485c4242a8 ("bpf: add bpf_skb_change_type helper")
6578171a7ff0 ("bpf: add bpf_skb_change_proto helper")
Changes detected by the tools build system:
$ make -C tools/perf O=/tmp/build/perf install-bin
make: Entering directory '/home/acme/git/linux/tools/perf'
BUILD: Doing 'make -j4' parallel build
Warning: tools/include/uapi/linux/bpf.h differs from kernel
INSTALL GTK UI
CC /tmp/build/perf/bench/mem-memcpy-x86-64-asm.o
<SNIP>
$
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexei Starovoitov <ast@fb.com>
Cc: Brenden Blanco <bblanco@plumgrid.com>
Cc: Daniel Borkmann <daniel@iogearbox.net>
Cc: David Ahern <dsahern@gmail.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Martin KaFai Lau <kafai@fb.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Sargun Dhillon <sargun@sargun.me>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/n/tip-difq4ts1xvww6eyfs9e7zlft@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-08-09 14:48:07 +00:00
|
|
|
BPF_PROG_TYPE_XDP,
|
2016-12-09 02:46:14 +00:00
|
|
|
BPF_PROG_TYPE_PERF_EVENT,
|
|
|
|
|
BPF_PROG_TYPE_CGROUP_SKB,
|
|
|
|
|
BPF_PROG_TYPE_CGROUP_SOCK,
|
|
|
|
|
BPF_PROG_TYPE_LWT_IN,
|
|
|
|
|
BPF_PROG_TYPE_LWT_OUT,
|
|
|
|
|
BPF_PROG_TYPE_LWT_XMIT,
|
2017-07-01 03:02:55 +00:00
|
|
|
BPF_PROG_TYPE_SOCK_OPS,
|
2017-08-16 05:33:32 +00:00
|
|
|
BPF_PROG_TYPE_SK_SKB,
|
2017-11-05 13:15:32 +00:00
|
|
|
BPF_PROG_TYPE_CGROUP_DEVICE,
|
2016-07-11 19:38:05 +00:00
|
|
|
};
|
|
|
|
|
|
2016-12-09 02:46:14 +00:00
|
|
|
enum bpf_attach_type {
|
|
|
|
|
BPF_CGROUP_INET_INGRESS,
|
|
|
|
|
BPF_CGROUP_INET_EGRESS,
|
|
|
|
|
BPF_CGROUP_INET_SOCK_CREATE,
|
2017-07-01 03:02:55 +00:00
|
|
|
BPF_CGROUP_SOCK_OPS,
|
2017-08-28 14:10:04 +00:00
|
|
|
BPF_SK_SKB_STREAM_PARSER,
|
|
|
|
|
BPF_SK_SKB_STREAM_VERDICT,
|
2017-11-05 13:15:32 +00:00
|
|
|
BPF_CGROUP_DEVICE,
|
2016-12-09 02:46:14 +00:00
|
|
|
__MAX_BPF_ATTACH_TYPE
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define MAX_BPF_ATTACH_TYPE __MAX_BPF_ATTACH_TYPE
|
|
|
|
|
|
2017-10-03 05:50:26 +00:00
|
|
|
/* cgroup-bpf attach flags used in BPF_PROG_ATTACH command
|
|
|
|
|
*
|
|
|
|
|
* NONE(default): No further bpf programs allowed in the subtree.
|
|
|
|
|
*
|
|
|
|
|
* BPF_F_ALLOW_OVERRIDE: If a sub-cgroup installs some bpf program,
|
|
|
|
|
* the program in this cgroup yields to sub-cgroup program.
|
|
|
|
|
*
|
|
|
|
|
* BPF_F_ALLOW_MULTI: If a sub-cgroup installs some bpf program,
|
|
|
|
|
* that cgroup program gets run in addition to the program in this cgroup.
|
|
|
|
|
*
|
|
|
|
|
* Only one program is allowed to be attached to a cgroup with
|
|
|
|
|
* NONE or BPF_F_ALLOW_OVERRIDE flag.
|
|
|
|
|
* Attaching another program on top of NONE or BPF_F_ALLOW_OVERRIDE will
|
|
|
|
|
* release old program and attach the new one. Attach flags has to match.
|
|
|
|
|
*
|
|
|
|
|
* Multiple programs are allowed to be attached to a cgroup with
|
|
|
|
|
* BPF_F_ALLOW_MULTI flag. They are executed in FIFO order
|
|
|
|
|
* (those that were attached first, run first)
|
|
|
|
|
* The programs of sub-cgroup are executed first, then programs of
|
|
|
|
|
* this cgroup and then programs of parent cgroup.
|
|
|
|
|
* When children program makes decision (like picking TCP CA or sock bind)
|
|
|
|
|
* parent program has a chance to override it.
|
|
|
|
|
*
|
|
|
|
|
* A cgroup with MULTI or OVERRIDE flag allows any attach flags in sub-cgroups.
|
|
|
|
|
* A cgroup with NONE doesn't allow any programs in sub-cgroups.
|
|
|
|
|
* Ex1:
|
|
|
|
|
* cgrp1 (MULTI progs A, B) ->
|
|
|
|
|
* cgrp2 (OVERRIDE prog C) ->
|
|
|
|
|
* cgrp3 (MULTI prog D) ->
|
|
|
|
|
* cgrp4 (OVERRIDE prog E) ->
|
|
|
|
|
* cgrp5 (NONE prog F)
|
|
|
|
|
* the event in cgrp5 triggers execution of F,D,A,B in that order.
|
|
|
|
|
* if prog F is detached, the execution is E,D,A,B
|
|
|
|
|
* if prog F and D are detached, the execution is E,A,B
|
|
|
|
|
* if prog F, E and D are detached, the execution is C,A,B
|
|
|
|
|
*
|
|
|
|
|
* All eligible programs are executed regardless of return code from
|
|
|
|
|
* earlier programs.
|
2017-02-13 21:22:20 +00:00
|
|
|
*/
|
|
|
|
|
#define BPF_F_ALLOW_OVERRIDE (1U << 0)
|
2017-10-03 05:50:26 +00:00
|
|
|
#define BPF_F_ALLOW_MULTI (1U << 1)
|
2017-02-13 21:22:20 +00:00
|
|
|
|
2017-05-10 18:38:07 +00:00
|
|
|
/* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the
|
|
|
|
|
* verifier will perform strict alignment checking as if the kernel
|
|
|
|
|
* has been built with CONFIG_EFFICIENT_UNALIGNED_ACCESS not set,
|
|
|
|
|
* and NET_IP_ALIGN defined to 2.
|
|
|
|
|
*/
|
|
|
|
|
#define BPF_F_STRICT_ALIGNMENT (1U << 0)
|
|
|
|
|
|
2017-12-15 01:55:10 +00:00
|
|
|
/* when bpf_ldimm64->src_reg == BPF_PSEUDO_MAP_FD, bpf_ldimm64->imm == fd */
|
2016-07-11 19:38:05 +00:00
|
|
|
#define BPF_PSEUDO_MAP_FD 1
|
|
|
|
|
|
2017-12-15 01:55:10 +00:00
|
|
|
/* when bpf_call->src_reg == BPF_PSEUDO_CALL, bpf_call->imm == pc-relative
|
|
|
|
|
* offset to another bpf function
|
|
|
|
|
*/
|
|
|
|
|
#define BPF_PSEUDO_CALL 1
|
|
|
|
|
|
2016-07-11 19:38:05 +00:00
|
|
|
/* flags for BPF_MAP_UPDATE_ELEM command */
|
|
|
|
|
#define BPF_ANY 0 /* create new element or update existing */
|
|
|
|
|
#define BPF_NOEXIST 1 /* create new element if it didn't exist */
|
|
|
|
|
#define BPF_EXIST 2 /* update existing element */
|
|
|
|
|
|
2017-08-18 18:28:01 +00:00
|
|
|
/* flags for BPF_MAP_CREATE command */
|
2016-07-11 19:38:05 +00:00
|
|
|
#define BPF_F_NO_PREALLOC (1U << 0)
|
2016-12-09 02:46:14 +00:00
|
|
|
/* Instead of having one common LRU list in the
|
|
|
|
|
* BPF_MAP_TYPE_LRU_[PERCPU_]HASH map, use a percpu LRU list
|
|
|
|
|
* which can scale and perform better.
|
|
|
|
|
* Note, the LRU nodes (including free nodes) cannot be moved
|
|
|
|
|
* across different LRU lists.
|
|
|
|
|
*/
|
|
|
|
|
#define BPF_F_NO_COMMON_LRU (1U << 1)
|
2017-08-18 18:28:01 +00:00
|
|
|
/* Specify numa node during map creation */
|
|
|
|
|
#define BPF_F_NUMA_NODE (1U << 2)
|
2016-07-11 19:38:05 +00:00
|
|
|
|
2017-10-03 05:50:26 +00:00
|
|
|
/* flags for BPF_PROG_QUERY */
|
|
|
|
|
#define BPF_F_QUERY_EFFECTIVE (1U << 0)
|
|
|
|
|
|
2017-09-27 21:37:54 +00:00
|
|
|
#define BPF_OBJ_NAME_LEN 16U
|
|
|
|
|
|
2017-10-22 17:29:06 +00:00
|
|
|
/* Flags for accessing BPF object */
|
|
|
|
|
#define BPF_F_RDONLY (1U << 3)
|
|
|
|
|
#define BPF_F_WRONLY (1U << 4)
|
|
|
|
|
|
2018-03-14 17:23:22 +00:00
|
|
|
/* Flag for stack_map, store build_id+offset instead of pointer */
|
|
|
|
|
#define BPF_F_STACK_BUILD_ID (1U << 5)
|
|
|
|
|
|
|
|
|
|
enum bpf_stack_build_id_status {
|
|
|
|
|
/* user space need an empty entry to identify end of a trace */
|
|
|
|
|
BPF_STACK_BUILD_ID_EMPTY = 0,
|
|
|
|
|
/* with valid build_id and offset */
|
|
|
|
|
BPF_STACK_BUILD_ID_VALID = 1,
|
|
|
|
|
/* couldn't get build_id, fallback to ip */
|
|
|
|
|
BPF_STACK_BUILD_ID_IP = 2,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define BPF_BUILD_ID_SIZE 20
|
|
|
|
|
struct bpf_stack_build_id {
|
|
|
|
|
__s32 status;
|
|
|
|
|
unsigned char build_id[BPF_BUILD_ID_SIZE];
|
|
|
|
|
union {
|
|
|
|
|
__u64 offset;
|
|
|
|
|
__u64 ip;
|
|
|
|
|
};
|
|
|
|
|
};
|
|
|
|
|
|
2016-07-11 19:38:05 +00:00
|
|
|
union bpf_attr {
|
|
|
|
|
struct { /* anonymous struct used by BPF_MAP_CREATE command */
|
|
|
|
|
__u32 map_type; /* one of enum bpf_map_type */
|
|
|
|
|
__u32 key_size; /* size of key in bytes */
|
|
|
|
|
__u32 value_size; /* size of value in bytes */
|
|
|
|
|
__u32 max_entries; /* max number of entries in a map */
|
2017-08-18 18:28:01 +00:00
|
|
|
__u32 map_flags; /* BPF_MAP_CREATE related
|
|
|
|
|
* flags defined above.
|
|
|
|
|
*/
|
2017-03-22 17:00:35 +00:00
|
|
|
__u32 inner_map_fd; /* fd pointing to the inner map */
|
2017-08-18 18:28:01 +00:00
|
|
|
__u32 numa_node; /* numa node (effective only if
|
|
|
|
|
* BPF_F_NUMA_NODE is set).
|
|
|
|
|
*/
|
2017-10-06 04:52:12 +00:00
|
|
|
char map_name[BPF_OBJ_NAME_LEN];
|
2018-01-12 04:29:09 +00:00
|
|
|
__u32 map_ifindex; /* ifindex of netdev to create on */
|
2016-07-11 19:38:05 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct { /* anonymous struct used by BPF_MAP_*_ELEM commands */
|
|
|
|
|
__u32 map_fd;
|
|
|
|
|
__aligned_u64 key;
|
|
|
|
|
union {
|
|
|
|
|
__aligned_u64 value;
|
|
|
|
|
__aligned_u64 next_key;
|
|
|
|
|
};
|
|
|
|
|
__u64 flags;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct { /* anonymous struct used by BPF_PROG_LOAD command */
|
|
|
|
|
__u32 prog_type; /* one of enum bpf_prog_type */
|
|
|
|
|
__u32 insn_cnt;
|
|
|
|
|
__aligned_u64 insns;
|
|
|
|
|
__aligned_u64 license;
|
|
|
|
|
__u32 log_level; /* verbosity level of verifier */
|
|
|
|
|
__u32 log_size; /* size of user buffer */
|
|
|
|
|
__aligned_u64 log_buf; /* user supplied buffer */
|
|
|
|
|
__u32 kern_version; /* checked when prog_type=kprobe */
|
2017-05-10 18:38:07 +00:00
|
|
|
__u32 prog_flags;
|
2017-10-06 04:52:12 +00:00
|
|
|
char prog_name[BPF_OBJ_NAME_LEN];
|
2017-11-20 23:21:53 +00:00
|
|
|
__u32 prog_ifindex; /* ifindex of netdev to prep for */
|
2016-07-11 19:38:05 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct { /* anonymous struct used by BPF_OBJ_* commands */
|
|
|
|
|
__aligned_u64 pathname;
|
|
|
|
|
__u32 bpf_fd;
|
2017-10-22 17:29:06 +00:00
|
|
|
__u32 file_flags;
|
2016-07-11 19:38:05 +00:00
|
|
|
};
|
2016-12-09 02:46:14 +00:00
|
|
|
|
|
|
|
|
struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */
|
|
|
|
|
__u32 target_fd; /* container object to attach to */
|
|
|
|
|
__u32 attach_bpf_fd; /* eBPF program to attach */
|
|
|
|
|
__u32 attach_type;
|
2017-02-13 21:22:20 +00:00
|
|
|
__u32 attach_flags;
|
2016-12-09 02:46:14 +00:00
|
|
|
};
|
2017-03-31 04:45:39 +00:00
|
|
|
|
|
|
|
|
struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */
|
|
|
|
|
__u32 prog_fd;
|
|
|
|
|
__u32 retval;
|
|
|
|
|
__u32 data_size_in;
|
|
|
|
|
__u32 data_size_out;
|
|
|
|
|
__aligned_u64 data_in;
|
|
|
|
|
__aligned_u64 data_out;
|
|
|
|
|
__u32 repeat;
|
|
|
|
|
__u32 duration;
|
|
|
|
|
} test;
|
2017-06-05 19:15:53 +00:00
|
|
|
|
|
|
|
|
struct { /* anonymous struct used by BPF_*_GET_*_ID */
|
|
|
|
|
union {
|
|
|
|
|
__u32 start_id;
|
|
|
|
|
__u32 prog_id;
|
|
|
|
|
__u32 map_id;
|
|
|
|
|
};
|
|
|
|
|
__u32 next_id;
|
2017-10-22 17:29:06 +00:00
|
|
|
__u32 open_flags;
|
2017-06-05 19:15:53 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct { /* anonymous struct used by BPF_OBJ_GET_INFO_BY_FD */
|
|
|
|
|
__u32 bpf_fd;
|
|
|
|
|
__u32 info_len;
|
|
|
|
|
__aligned_u64 info;
|
|
|
|
|
} info;
|
2017-10-03 05:50:26 +00:00
|
|
|
|
|
|
|
|
struct { /* anonymous struct used by BPF_PROG_QUERY command */
|
|
|
|
|
__u32 target_fd; /* container object to query */
|
|
|
|
|
__u32 attach_type;
|
|
|
|
|
__u32 query_flags;
|
|
|
|
|
__u32 attach_flags;
|
|
|
|
|
__aligned_u64 prog_ids;
|
|
|
|
|
__u32 prog_cnt;
|
|
|
|
|
} query;
|
2016-07-11 19:38:05 +00:00
|
|
|
} __attribute__((aligned(8)));
|
|
|
|
|
|
2016-12-09 02:46:14 +00:00
|
|
|
/* BPF helper function descriptions:
|
|
|
|
|
*
|
|
|
|
|
* void *bpf_map_lookup_elem(&map, &key)
|
|
|
|
|
* Return: Map value or NULL
|
|
|
|
|
*
|
|
|
|
|
* int bpf_map_update_elem(&map, &key, &value, flags)
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_map_delete_elem(&map, &key)
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_probe_read(void *dst, int size, void *src)
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* u64 bpf_ktime_get_ns(void)
|
|
|
|
|
* Return: current ktime
|
|
|
|
|
*
|
|
|
|
|
* int bpf_trace_printk(const char *fmt, int fmt_size, ...)
|
|
|
|
|
* Return: length of buffer written or negative error
|
|
|
|
|
*
|
|
|
|
|
* u32 bpf_prandom_u32(void)
|
|
|
|
|
* Return: random value
|
|
|
|
|
*
|
|
|
|
|
* u32 bpf_raw_smp_processor_id(void)
|
|
|
|
|
* Return: SMP processor ID
|
|
|
|
|
*
|
|
|
|
|
* int bpf_skb_store_bytes(skb, offset, from, len, flags)
|
|
|
|
|
* store bytes into packet
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @offset: offset within packet from skb->mac_header
|
|
|
|
|
* @from: pointer where to copy bytes from
|
|
|
|
|
* @len: number of bytes to store into packet
|
|
|
|
|
* @flags: bit 0 - if true, recompute skb->csum
|
|
|
|
|
* other bits - reserved
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_l3_csum_replace(skb, offset, from, to, flags)
|
|
|
|
|
* recompute IP checksum
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @offset: offset within packet where IP checksum is located
|
|
|
|
|
* @from: old value of header field
|
|
|
|
|
* @to: new value of header field
|
|
|
|
|
* @flags: bits 0-3 - size of header field
|
|
|
|
|
* other bits - reserved
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_l4_csum_replace(skb, offset, from, to, flags)
|
|
|
|
|
* recompute TCP/UDP checksum
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @offset: offset within packet where TCP/UDP checksum is located
|
|
|
|
|
* @from: old value of header field
|
|
|
|
|
* @to: new value of header field
|
|
|
|
|
* @flags: bits 0-3 - size of header field
|
|
|
|
|
* bit 4 - is pseudo header
|
|
|
|
|
* other bits - reserved
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_tail_call(ctx, prog_array_map, index)
|
|
|
|
|
* jump into another BPF program
|
|
|
|
|
* @ctx: context pointer passed to next program
|
|
|
|
|
* @prog_array_map: pointer to map which type is BPF_MAP_TYPE_PROG_ARRAY
|
2017-10-09 18:55:45 +00:00
|
|
|
* @index: 32-bit index inside array that selects specific program to run
|
2016-12-09 02:46:14 +00:00
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_clone_redirect(skb, ifindex, flags)
|
|
|
|
|
* redirect to another netdev
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @ifindex: ifindex of the net device
|
|
|
|
|
* @flags: bit 0 - if set, redirect to ingress instead of egress
|
|
|
|
|
* other bits - reserved
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* u64 bpf_get_current_pid_tgid(void)
|
|
|
|
|
* Return: current->tgid << 32 | current->pid
|
|
|
|
|
*
|
|
|
|
|
* u64 bpf_get_current_uid_gid(void)
|
|
|
|
|
* Return: current_gid << 32 | current_uid
|
|
|
|
|
*
|
|
|
|
|
* int bpf_get_current_comm(char *buf, int size_of_buf)
|
|
|
|
|
* stores current->comm into buf
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* u32 bpf_get_cgroup_classid(skb)
|
|
|
|
|
* retrieve a proc's classid
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* Return: classid if != 0
|
|
|
|
|
*
|
|
|
|
|
* int bpf_skb_vlan_push(skb, vlan_proto, vlan_tci)
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_skb_vlan_pop(skb)
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_skb_get_tunnel_key(skb, key, size, flags)
|
|
|
|
|
* int bpf_skb_set_tunnel_key(skb, key, size, flags)
|
|
|
|
|
* retrieve or populate tunnel metadata
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @key: pointer to 'struct bpf_tunnel_key'
|
|
|
|
|
* @size: size of 'struct bpf_tunnel_key'
|
|
|
|
|
* @flags: room for future extensions
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
2017-06-03 04:03:54 +00:00
|
|
|
* u64 bpf_perf_event_read(map, flags)
|
|
|
|
|
* read perf event counter value
|
|
|
|
|
* @map: pointer to perf_event_array map
|
|
|
|
|
* @flags: index of event in the map or bitmask flags
|
|
|
|
|
* Return: value of perf event counter read or error code
|
2016-12-09 02:46:14 +00:00
|
|
|
*
|
|
|
|
|
* int bpf_redirect(ifindex, flags)
|
|
|
|
|
* redirect to another netdev
|
|
|
|
|
* @ifindex: ifindex of the net device
|
2017-09-25 00:25:52 +00:00
|
|
|
* @flags:
|
|
|
|
|
* cls_bpf:
|
|
|
|
|
* bit 0 - if set, redirect to ingress instead of egress
|
|
|
|
|
* other bits - reserved
|
|
|
|
|
* xdp_bpf:
|
|
|
|
|
* all bits - reserved
|
|
|
|
|
* Return: cls_bpf: TC_ACT_REDIRECT on success or TC_ACT_SHOT on error
|
|
|
|
|
* xdp_bfp: XDP_REDIRECT on success or XDP_ABORT on error
|
|
|
|
|
* int bpf_redirect_map(map, key, flags)
|
|
|
|
|
* redirect to endpoint in map
|
|
|
|
|
* @map: pointer to dev map
|
|
|
|
|
* @key: index in map to lookup
|
|
|
|
|
* @flags: --
|
|
|
|
|
* Return: XDP_REDIRECT on success or XDP_ABORT on error
|
2016-12-09 02:46:14 +00:00
|
|
|
*
|
|
|
|
|
* u32 bpf_get_route_realm(skb)
|
|
|
|
|
* retrieve a dst's tclassid
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* Return: realm if != 0
|
|
|
|
|
*
|
2017-06-03 04:03:54 +00:00
|
|
|
* int bpf_perf_event_output(ctx, map, flags, data, size)
|
2016-12-09 02:46:14 +00:00
|
|
|
* output perf raw sample
|
|
|
|
|
* @ctx: struct pt_regs*
|
|
|
|
|
* @map: pointer to perf_event_array map
|
2017-06-03 04:03:54 +00:00
|
|
|
* @flags: index of event in the map or bitmask flags
|
2016-12-09 02:46:14 +00:00
|
|
|
* @data: data on stack to be output as raw data
|
|
|
|
|
* @size: size of data
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_get_stackid(ctx, map, flags)
|
|
|
|
|
* walk user or kernel stack and return id
|
|
|
|
|
* @ctx: struct pt_regs*
|
|
|
|
|
* @map: pointer to stack_trace map
|
|
|
|
|
* @flags: bits 0-7 - numer of stack frames to skip
|
|
|
|
|
* bit 8 - collect user stack instead of kernel
|
|
|
|
|
* bit 9 - compare stacks by hash only
|
|
|
|
|
* bit 10 - if two different stacks hash into the same stackid
|
|
|
|
|
* discard old
|
|
|
|
|
* other bits - reserved
|
|
|
|
|
* Return: >= 0 stackid on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* s64 bpf_csum_diff(from, from_size, to, to_size, seed)
|
|
|
|
|
* calculate csum diff
|
|
|
|
|
* @from: raw from buffer
|
|
|
|
|
* @from_size: length of from buffer
|
|
|
|
|
* @to: raw to buffer
|
|
|
|
|
* @to_size: length of to buffer
|
|
|
|
|
* @seed: optional seed
|
|
|
|
|
* Return: csum result or negative error code
|
|
|
|
|
*
|
|
|
|
|
* int bpf_skb_get_tunnel_opt(skb, opt, size)
|
|
|
|
|
* retrieve tunnel options metadata
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @opt: pointer to raw tunnel option data
|
|
|
|
|
* @size: size of @opt
|
|
|
|
|
* Return: option size
|
|
|
|
|
*
|
|
|
|
|
* int bpf_skb_set_tunnel_opt(skb, opt, size)
|
|
|
|
|
* populate tunnel options metadata
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @opt: pointer to raw tunnel option data
|
|
|
|
|
* @size: size of @opt
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_skb_change_proto(skb, proto, flags)
|
|
|
|
|
* Change protocol of the skb. Currently supported is v4 -> v6,
|
|
|
|
|
* v6 -> v4 transitions. The helper will also resize the skb. eBPF
|
|
|
|
|
* program is expected to fill the new headers via skb_store_bytes
|
|
|
|
|
* and lX_csum_replace.
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @proto: new skb->protocol type
|
|
|
|
|
* @flags: reserved
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_skb_change_type(skb, type)
|
|
|
|
|
* Change packet type of skb.
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @type: new skb->pkt_type type
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_skb_under_cgroup(skb, map, index)
|
|
|
|
|
* Check cgroup2 membership of skb
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @map: pointer to bpf_map in BPF_MAP_TYPE_CGROUP_ARRAY type
|
|
|
|
|
* @index: index of the cgroup in the bpf_map
|
|
|
|
|
* Return:
|
|
|
|
|
* == 0 skb failed the cgroup2 descendant test
|
|
|
|
|
* == 1 skb succeeded the cgroup2 descendant test
|
|
|
|
|
* < 0 error
|
|
|
|
|
*
|
|
|
|
|
* u32 bpf_get_hash_recalc(skb)
|
|
|
|
|
* Retrieve and possibly recalculate skb->hash.
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* Return: hash
|
|
|
|
|
*
|
|
|
|
|
* u64 bpf_get_current_task(void)
|
|
|
|
|
* Returns current task_struct
|
|
|
|
|
* Return: current
|
|
|
|
|
*
|
|
|
|
|
* int bpf_probe_write_user(void *dst, void *src, int len)
|
|
|
|
|
* safely attempt to write to a location
|
|
|
|
|
* @dst: destination address in userspace
|
|
|
|
|
* @src: source address on stack
|
|
|
|
|
* @len: number of bytes to copy
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_current_task_under_cgroup(map, index)
|
|
|
|
|
* Check cgroup2 membership of current task
|
|
|
|
|
* @map: pointer to bpf_map in BPF_MAP_TYPE_CGROUP_ARRAY type
|
|
|
|
|
* @index: index of the cgroup in the bpf_map
|
|
|
|
|
* Return:
|
|
|
|
|
* == 0 current failed the cgroup2 descendant test
|
|
|
|
|
* == 1 current succeeded the cgroup2 descendant test
|
|
|
|
|
* < 0 error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_skb_change_tail(skb, len, flags)
|
|
|
|
|
* The helper will resize the skb to the given new size, to be used f.e.
|
|
|
|
|
* with control messages.
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @len: new skb length
|
|
|
|
|
* @flags: reserved
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_skb_pull_data(skb, len)
|
|
|
|
|
* The helper will pull in non-linear data in case the skb is non-linear
|
|
|
|
|
* and not all of len are part of the linear section. Only needed for
|
|
|
|
|
* read/write with direct packet access.
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @len: len to make read/writeable
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* s64 bpf_csum_update(skb, csum)
|
|
|
|
|
* Adds csum into skb->csum in case of CHECKSUM_COMPLETE.
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @csum: csum to add
|
|
|
|
|
* Return: csum on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* void bpf_set_hash_invalid(skb)
|
|
|
|
|
* Invalidate current skb->hash.
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
*
|
|
|
|
|
* int bpf_get_numa_node_id()
|
|
|
|
|
* Return: Id of current NUMA node.
|
|
|
|
|
*
|
|
|
|
|
* int bpf_skb_change_head()
|
|
|
|
|
* Grows headroom of skb and adjusts MAC header offset accordingly.
|
|
|
|
|
* Will extends/reallocae as required automatically.
|
|
|
|
|
* May change skb data pointer and will thus invalidate any check
|
|
|
|
|
* performed for direct packet access.
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @len: length of header to be pushed in front
|
|
|
|
|
* @flags: Flags (unused for now)
|
|
|
|
|
* Return: 0 on success or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_xdp_adjust_head(xdp_md, delta)
|
|
|
|
|
* Adjust the xdp_md.data by delta
|
|
|
|
|
* @xdp_md: pointer to xdp_md
|
|
|
|
|
* @delta: An positive/negative integer to be added to xdp_md.data
|
|
|
|
|
* Return: 0 on success or negative on error
|
2017-02-09 23:21:35 +00:00
|
|
|
*
|
|
|
|
|
* int bpf_probe_read_str(void *dst, int size, const void *unsafe_ptr)
|
|
|
|
|
* Copy a NUL terminated string from unsafe address. In case the string
|
|
|
|
|
* length is smaller than size, the target is not padded with further NUL
|
|
|
|
|
* bytes. In case the string length is larger than size, just count-1
|
|
|
|
|
* bytes are copied and the last byte is set to NUL.
|
|
|
|
|
* @dst: destination address
|
|
|
|
|
* @size: maximum number of bytes to copy, including the trailing NUL
|
|
|
|
|
* @unsafe_ptr: unsafe address
|
|
|
|
|
* Return:
|
|
|
|
|
* > 0 length of the string including the trailing NUL on success
|
|
|
|
|
* < 0 error
|
2017-03-31 04:45:39 +00:00
|
|
|
*
|
2017-04-08 20:08:10 +00:00
|
|
|
* u64 bpf_get_socket_cookie(skb)
|
2017-03-31 04:45:39 +00:00
|
|
|
* Get the cookie for the socket stored inside sk_buff.
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* Return: 8 Bytes non-decreasing number on success or 0 if the socket
|
|
|
|
|
* field is missing inside sk_buff
|
|
|
|
|
*
|
|
|
|
|
* u32 bpf_get_socket_uid(skb)
|
|
|
|
|
* Get the owner uid of the socket stored inside sk_buff.
|
|
|
|
|
* @skb: pointer to skb
|
2017-05-10 18:38:07 +00:00
|
|
|
* Return: uid of the socket owner on success or overflowuid if failed.
|
2017-06-10 22:50:47 +00:00
|
|
|
*
|
|
|
|
|
* u32 bpf_set_hash(skb, hash)
|
|
|
|
|
* Set full skb->hash.
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @hash: hash to set
|
2017-07-01 03:02:55 +00:00
|
|
|
*
|
|
|
|
|
* int bpf_setsockopt(bpf_socket, level, optname, optval, optlen)
|
|
|
|
|
* Calls setsockopt. Not all opts are available, only those with
|
|
|
|
|
* integer optvals plus TCP_CONGESTION.
|
2017-10-22 17:29:06 +00:00
|
|
|
* Supported levels: SOL_SOCKET and IPPROTO_TCP
|
2017-07-01 03:02:55 +00:00
|
|
|
* @bpf_socket: pointer to bpf_socket
|
2017-10-22 17:29:06 +00:00
|
|
|
* @level: SOL_SOCKET or IPPROTO_TCP
|
2017-07-01 03:02:55 +00:00
|
|
|
* @optname: option name
|
|
|
|
|
* @optval: pointer to option value
|
2017-10-22 17:29:06 +00:00
|
|
|
* @optlen: length of optval in bytes
|
|
|
|
|
* Return: 0 or negative error
|
|
|
|
|
*
|
|
|
|
|
* int bpf_getsockopt(bpf_socket, level, optname, optval, optlen)
|
|
|
|
|
* Calls getsockopt. Not all opts are available.
|
|
|
|
|
* Supported levels: IPPROTO_TCP
|
|
|
|
|
* @bpf_socket: pointer to bpf_socket
|
|
|
|
|
* @level: IPPROTO_TCP
|
|
|
|
|
* @optname: option name
|
|
|
|
|
* @optval: pointer to option value
|
|
|
|
|
* @optlen: length of optval in bytes
|
2017-07-01 03:02:55 +00:00
|
|
|
* Return: 0 or negative error
|
2017-07-02 00:13:26 +00:00
|
|
|
*
|
2018-01-26 00:14:16 +00:00
|
|
|
* int bpf_sock_ops_cb_flags_set(bpf_sock_ops, flags)
|
|
|
|
|
* Set callback flags for sock_ops
|
|
|
|
|
* @bpf_sock_ops: pointer to bpf_sock_ops_kern struct
|
|
|
|
|
* @flags: flags value
|
|
|
|
|
* Return: 0 for no error
|
|
|
|
|
* -EINVAL if there is no full tcp socket
|
|
|
|
|
* bits in flags that are not supported by current kernel
|
|
|
|
|
*
|
2017-07-02 00:13:26 +00:00
|
|
|
* int bpf_skb_adjust_room(skb, len_diff, mode, flags)
|
|
|
|
|
* Grow or shrink room in sk_buff.
|
|
|
|
|
* @skb: pointer to skb
|
|
|
|
|
* @len_diff: (signed) amount of room to grow/shrink
|
|
|
|
|
* @mode: operation mode (enum bpf_adj_room_mode)
|
|
|
|
|
* @flags: reserved for future use
|
|
|
|
|
* Return: 0 on success or negative error code
|
2017-08-16 05:33:32 +00:00
|
|
|
*
|
2017-10-22 17:29:06 +00:00
|
|
|
* int bpf_sk_redirect_map(map, key, flags)
|
2017-08-16 05:33:32 +00:00
|
|
|
* Redirect skb to a sock in map using key as a lookup key for the
|
|
|
|
|
* sock in map.
|
|
|
|
|
* @map: pointer to sockmap
|
|
|
|
|
* @key: key to lookup sock in map
|
|
|
|
|
* @flags: reserved for future use
|
2017-11-01 02:17:31 +00:00
|
|
|
* Return: SK_PASS
|
2017-08-16 05:33:32 +00:00
|
|
|
*
|
2017-08-28 14:10:04 +00:00
|
|
|
* int bpf_sock_map_update(skops, map, key, flags)
|
2017-08-16 05:33:32 +00:00
|
|
|
* @skops: pointer to bpf_sock_ops
|
|
|
|
|
* @map: pointer to sockmap to update
|
|
|
|
|
* @key: key to insert/update sock in map
|
|
|
|
|
* @flags: same flags as map update elem
|
2017-09-25 00:25:52 +00:00
|
|
|
*
|
|
|
|
|
* int bpf_xdp_adjust_meta(xdp_md, delta)
|
|
|
|
|
* Adjust the xdp_md.data_meta by delta
|
|
|
|
|
* @xdp_md: pointer to xdp_md
|
|
|
|
|
* @delta: An positive/negative integer to be added to xdp_md.data_meta
|
|
|
|
|
* Return: 0 on success or negative on error
|
2017-10-22 17:29:06 +00:00
|
|
|
*
|
|
|
|
|
* int bpf_perf_event_read_value(map, flags, buf, buf_size)
|
|
|
|
|
* read perf event counter value and perf event enabled/running time
|
|
|
|
|
* @map: pointer to perf_event_array map
|
|
|
|
|
* @flags: index of event in the map or bitmask flags
|
|
|
|
|
* @buf: buf to fill
|
|
|
|
|
* @buf_size: size of the buf
|
|
|
|
|
* Return: 0 on success or negative error code
|
|
|
|
|
*
|
|
|
|
|
* int bpf_perf_prog_read_value(ctx, buf, buf_size)
|
|
|
|
|
* read perf prog attached perf event counter and enabled/running time
|
|
|
|
|
* @ctx: pointer to ctx
|
|
|
|
|
* @buf: buf to fill
|
|
|
|
|
* @buf_size: size of the buf
|
|
|
|
|
* Return : 0 on success or negative error code
|
2017-12-11 16:36:49 +00:00
|
|
|
*
|
|
|
|
|
* int bpf_override_return(pt_regs, rc)
|
|
|
|
|
* @pt_regs: pointer to struct pt_regs
|
|
|
|
|
* @rc: the return value to set
|
2016-12-09 02:46:14 +00:00
|
|
|
*/
|
|
|
|
|
#define __BPF_FUNC_MAPPER(FN) \
|
|
|
|
|
FN(unspec), \
|
|
|
|
|
FN(map_lookup_elem), \
|
|
|
|
|
FN(map_update_elem), \
|
|
|
|
|
FN(map_delete_elem), \
|
|
|
|
|
FN(probe_read), \
|
|
|
|
|
FN(ktime_get_ns), \
|
|
|
|
|
FN(trace_printk), \
|
|
|
|
|
FN(get_prandom_u32), \
|
|
|
|
|
FN(get_smp_processor_id), \
|
|
|
|
|
FN(skb_store_bytes), \
|
|
|
|
|
FN(l3_csum_replace), \
|
|
|
|
|
FN(l4_csum_replace), \
|
|
|
|
|
FN(tail_call), \
|
|
|
|
|
FN(clone_redirect), \
|
|
|
|
|
FN(get_current_pid_tgid), \
|
|
|
|
|
FN(get_current_uid_gid), \
|
|
|
|
|
FN(get_current_comm), \
|
|
|
|
|
FN(get_cgroup_classid), \
|
|
|
|
|
FN(skb_vlan_push), \
|
|
|
|
|
FN(skb_vlan_pop), \
|
|
|
|
|
FN(skb_get_tunnel_key), \
|
|
|
|
|
FN(skb_set_tunnel_key), \
|
|
|
|
|
FN(perf_event_read), \
|
|
|
|
|
FN(redirect), \
|
|
|
|
|
FN(get_route_realm), \
|
|
|
|
|
FN(perf_event_output), \
|
|
|
|
|
FN(skb_load_bytes), \
|
|
|
|
|
FN(get_stackid), \
|
|
|
|
|
FN(csum_diff), \
|
|
|
|
|
FN(skb_get_tunnel_opt), \
|
|
|
|
|
FN(skb_set_tunnel_opt), \
|
|
|
|
|
FN(skb_change_proto), \
|
|
|
|
|
FN(skb_change_type), \
|
|
|
|
|
FN(skb_under_cgroup), \
|
|
|
|
|
FN(get_hash_recalc), \
|
|
|
|
|
FN(get_current_task), \
|
|
|
|
|
FN(probe_write_user), \
|
|
|
|
|
FN(current_task_under_cgroup), \
|
|
|
|
|
FN(skb_change_tail), \
|
|
|
|
|
FN(skb_pull_data), \
|
|
|
|
|
FN(csum_update), \
|
|
|
|
|
FN(set_hash_invalid), \
|
|
|
|
|
FN(get_numa_node_id), \
|
|
|
|
|
FN(skb_change_head), \
|
2017-02-09 23:21:35 +00:00
|
|
|
FN(xdp_adjust_head), \
|
2017-03-23 00:27:34 +00:00
|
|
|
FN(probe_read_str), \
|
2017-03-23 00:27:35 +00:00
|
|
|
FN(get_socket_cookie), \
|
2017-06-10 22:50:47 +00:00
|
|
|
FN(get_socket_uid), \
|
2017-07-01 03:02:55 +00:00
|
|
|
FN(set_hash), \
|
2017-07-02 00:13:26 +00:00
|
|
|
FN(setsockopt), \
|
2017-08-07 20:14:42 +00:00
|
|
|
FN(skb_adjust_room), \
|
2017-08-16 05:33:32 +00:00
|
|
|
FN(redirect_map), \
|
|
|
|
|
FN(sk_redirect_map), \
|
2017-09-25 00:25:52 +00:00
|
|
|
FN(sock_map_update), \
|
2017-10-05 16:19:21 +00:00
|
|
|
FN(xdp_adjust_meta), \
|
2017-10-05 16:19:23 +00:00
|
|
|
FN(perf_event_read_value), \
|
2017-10-22 17:29:06 +00:00
|
|
|
FN(perf_prog_read_value), \
|
2017-12-11 16:36:49 +00:00
|
|
|
FN(getsockopt), \
|
2018-01-26 00:14:16 +00:00
|
|
|
FN(override_return), \
|
|
|
|
|
FN(sock_ops_cb_flags_set),
|
2016-12-09 02:46:14 +00:00
|
|
|
|
2016-07-11 19:38:05 +00:00
|
|
|
/* integer value in 'imm' field of BPF_CALL instruction selects which helper
|
|
|
|
|
* function eBPF program intends to call
|
|
|
|
|
*/
|
2016-12-09 02:46:14 +00:00
|
|
|
#define __BPF_ENUM_FN(x) BPF_FUNC_ ## x
|
2016-07-11 19:38:05 +00:00
|
|
|
enum bpf_func_id {
|
2016-12-09 02:46:14 +00:00
|
|
|
__BPF_FUNC_MAPPER(__BPF_ENUM_FN)
|
2016-07-11 19:38:05 +00:00
|
|
|
__BPF_FUNC_MAX_ID,
|
|
|
|
|
};
|
2016-12-09 02:46:14 +00:00
|
|
|
#undef __BPF_ENUM_FN
|
2016-07-11 19:38:05 +00:00
|
|
|
|
|
|
|
|
/* All flags used by eBPF helper functions, placed here. */
|
|
|
|
|
|
|
|
|
|
/* BPF_FUNC_skb_store_bytes flags. */
|
|
|
|
|
#define BPF_F_RECOMPUTE_CSUM (1ULL << 0)
|
|
|
|
|
#define BPF_F_INVALIDATE_HASH (1ULL << 1)
|
|
|
|
|
|
|
|
|
|
/* BPF_FUNC_l3_csum_replace and BPF_FUNC_l4_csum_replace flags.
|
|
|
|
|
* First 4 bits are for passing the header field size.
|
|
|
|
|
*/
|
|
|
|
|
#define BPF_F_HDR_FIELD_MASK 0xfULL
|
|
|
|
|
|
|
|
|
|
/* BPF_FUNC_l4_csum_replace flags. */
|
|
|
|
|
#define BPF_F_PSEUDO_HDR (1ULL << 4)
|
|
|
|
|
#define BPF_F_MARK_MANGLED_0 (1ULL << 5)
|
2017-02-09 23:21:35 +00:00
|
|
|
#define BPF_F_MARK_ENFORCE (1ULL << 6)
|
2016-07-11 19:38:05 +00:00
|
|
|
|
|
|
|
|
/* BPF_FUNC_clone_redirect and BPF_FUNC_redirect flags. */
|
|
|
|
|
#define BPF_F_INGRESS (1ULL << 0)
|
|
|
|
|
|
|
|
|
|
/* BPF_FUNC_skb_set_tunnel_key and BPF_FUNC_skb_get_tunnel_key flags. */
|
|
|
|
|
#define BPF_F_TUNINFO_IPV6 (1ULL << 0)
|
|
|
|
|
|
|
|
|
|
/* BPF_FUNC_get_stackid flags. */
|
|
|
|
|
#define BPF_F_SKIP_FIELD_MASK 0xffULL
|
|
|
|
|
#define BPF_F_USER_STACK (1ULL << 8)
|
|
|
|
|
#define BPF_F_FAST_STACK_CMP (1ULL << 9)
|
|
|
|
|
#define BPF_F_REUSE_STACKID (1ULL << 10)
|
|
|
|
|
|
|
|
|
|
/* BPF_FUNC_skb_set_tunnel_key flags. */
|
|
|
|
|
#define BPF_F_ZERO_CSUM_TX (1ULL << 1)
|
|
|
|
|
#define BPF_F_DONT_FRAGMENT (1ULL << 2)
|
|
|
|
|
|
2017-10-22 17:29:06 +00:00
|
|
|
/* BPF_FUNC_perf_event_output, BPF_FUNC_perf_event_read and
|
|
|
|
|
* BPF_FUNC_perf_event_read_value flags.
|
|
|
|
|
*/
|
2016-07-11 19:38:05 +00:00
|
|
|
#define BPF_F_INDEX_MASK 0xffffffffULL
|
|
|
|
|
#define BPF_F_CURRENT_CPU BPF_F_INDEX_MASK
|
toops: Sync tools/include/uapi/linux/bpf.h with the kernel
The way we're using kernel headers in tools/ now, with a copy that is
made to the same path prefixed by "tools/" plus checking if that copy
got stale, i.e. if the kernel counterpart changed, helps in keeping
track with new features that may be useful for tools to exploit.
For instance, looking at all the changes to bpf.h since it was last
copied to tools/include brings this to toolers' attention:
Need to investigate this one to check how to run a program via perf, setting up
a BPF event, that will take advantage of the way perf already calls clang/LLVM,
sets up the event and runs the workload in a single command line, helping in
debugging such semi cooperative programs:
96ae52279594 ("bpf: Add bpf_probe_write_user BPF helper to be called in tracers")
This one needs further investigation about using the feature it improves
in 'perf trace' to do some tcpdumpin' mixed with syscalls, tracepoints,
probe points, callgraphs, etc:
555c8a8623a3 ("bpf: avoid stack copy and use skb ctx for event output")
Add tracing just packets that are related to some container to that mix:
4a482f34afcc ("cgroup: bpf: Add bpf_skb_in_cgroup_proto")
4ed8ec521ed5 ("cgroup: bpf: Add BPF_MAP_TYPE_CGROUP_ARRAY")
Definetely needs to have example programs accessing task_struct from a bpf proggie
started from 'perf trace':
606274c5abd8 ("bpf: introduce bpf_get_current_task() helper")
Core networking related, XDP:
6ce96ca348a9 ("bpf: add XDP_TX xdp_action for direct forwarding")
6a773a15a1e8 ("bpf: add XDP prog type for early driver filter")
13c5c240f789 ("bpf: add bpf_get_hash_recalc helper")
d2485c4242a8 ("bpf: add bpf_skb_change_type helper")
6578171a7ff0 ("bpf: add bpf_skb_change_proto helper")
Changes detected by the tools build system:
$ make -C tools/perf O=/tmp/build/perf install-bin
make: Entering directory '/home/acme/git/linux/tools/perf'
BUILD: Doing 'make -j4' parallel build
Warning: tools/include/uapi/linux/bpf.h differs from kernel
INSTALL GTK UI
CC /tmp/build/perf/bench/mem-memcpy-x86-64-asm.o
<SNIP>
$
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexei Starovoitov <ast@fb.com>
Cc: Brenden Blanco <bblanco@plumgrid.com>
Cc: Daniel Borkmann <daniel@iogearbox.net>
Cc: David Ahern <dsahern@gmail.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Martin KaFai Lau <kafai@fb.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Sargun Dhillon <sargun@sargun.me>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/n/tip-difq4ts1xvww6eyfs9e7zlft@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-08-09 14:48:07 +00:00
|
|
|
/* BPF_FUNC_perf_event_output for sk_buff input context. */
|
|
|
|
|
#define BPF_F_CTXLEN_MASK (0xfffffULL << 32)
|
2016-07-11 19:38:05 +00:00
|
|
|
|
2017-07-02 00:13:26 +00:00
|
|
|
/* Mode for BPF_FUNC_skb_adjust_room helper. */
|
|
|
|
|
enum bpf_adj_room_mode {
|
2017-07-31 13:45:07 +00:00
|
|
|
BPF_ADJ_ROOM_NET,
|
2017-07-02 00:13:26 +00:00
|
|
|
};
|
|
|
|
|
|
2016-07-11 19:38:05 +00:00
|
|
|
/* user accessible mirror of in-kernel sk_buff.
|
|
|
|
|
* new fields can only be added to the end of this structure
|
|
|
|
|
*/
|
|
|
|
|
struct __sk_buff {
|
|
|
|
|
__u32 len;
|
|
|
|
|
__u32 pkt_type;
|
|
|
|
|
__u32 mark;
|
|
|
|
|
__u32 queue_mapping;
|
|
|
|
|
__u32 protocol;
|
|
|
|
|
__u32 vlan_present;
|
|
|
|
|
__u32 vlan_tci;
|
|
|
|
|
__u32 vlan_proto;
|
|
|
|
|
__u32 priority;
|
|
|
|
|
__u32 ingress_ifindex;
|
|
|
|
|
__u32 ifindex;
|
|
|
|
|
__u32 tc_index;
|
|
|
|
|
__u32 cb[5];
|
|
|
|
|
__u32 hash;
|
|
|
|
|
__u32 tc_classid;
|
|
|
|
|
__u32 data;
|
|
|
|
|
__u32 data_end;
|
2017-04-19 21:01:17 +00:00
|
|
|
__u32 napi_id;
|
2017-08-16 05:33:32 +00:00
|
|
|
|
2017-09-25 00:25:52 +00:00
|
|
|
/* Accessed by BPF_PROG_TYPE_sk_skb types from here to ... */
|
2017-08-16 05:33:32 +00:00
|
|
|
__u32 family;
|
|
|
|
|
__u32 remote_ip4; /* Stored in network byte order */
|
|
|
|
|
__u32 local_ip4; /* Stored in network byte order */
|
|
|
|
|
__u32 remote_ip6[4]; /* Stored in network byte order */
|
|
|
|
|
__u32 local_ip6[4]; /* Stored in network byte order */
|
|
|
|
|
__u32 remote_port; /* Stored in network byte order */
|
|
|
|
|
__u32 local_port; /* stored in host byte order */
|
2017-09-25 00:25:52 +00:00
|
|
|
/* ... here. */
|
|
|
|
|
|
|
|
|
|
__u32 data_meta;
|
2016-07-11 19:38:05 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct bpf_tunnel_key {
|
|
|
|
|
__u32 tunnel_id;
|
|
|
|
|
union {
|
|
|
|
|
__u32 remote_ipv4;
|
|
|
|
|
__u32 remote_ipv6[4];
|
|
|
|
|
};
|
|
|
|
|
__u8 tunnel_tos;
|
|
|
|
|
__u8 tunnel_ttl;
|
|
|
|
|
__u16 tunnel_ext;
|
|
|
|
|
__u32 tunnel_label;
|
|
|
|
|
};
|
|
|
|
|
|
2016-12-09 02:46:14 +00:00
|
|
|
/* Generic BPF return codes which all BPF program types may support.
|
|
|
|
|
* The values are binary compatible with their TC_ACT_* counter-part to
|
|
|
|
|
* provide backwards compatibility with existing SCHED_CLS and SCHED_ACT
|
|
|
|
|
* programs.
|
|
|
|
|
*
|
|
|
|
|
* XDP is handled seprately, see XDP_*.
|
|
|
|
|
*/
|
|
|
|
|
enum bpf_ret_code {
|
|
|
|
|
BPF_OK = 0,
|
|
|
|
|
/* 1 reserved */
|
|
|
|
|
BPF_DROP = 2,
|
|
|
|
|
/* 3-6 reserved */
|
|
|
|
|
BPF_REDIRECT = 7,
|
|
|
|
|
/* >127 are reserved for prog type specific return codes */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct bpf_sock {
|
|
|
|
|
__u32 bound_dev_if;
|
|
|
|
|
__u32 family;
|
|
|
|
|
__u32 type;
|
|
|
|
|
__u32 protocol;
|
2017-09-25 00:25:52 +00:00
|
|
|
__u32 mark;
|
|
|
|
|
__u32 priority;
|
2016-12-09 02:46:14 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define XDP_PACKET_HEADROOM 256
|
|
|
|
|
|
toops: Sync tools/include/uapi/linux/bpf.h with the kernel
The way we're using kernel headers in tools/ now, with a copy that is
made to the same path prefixed by "tools/" plus checking if that copy
got stale, i.e. if the kernel counterpart changed, helps in keeping
track with new features that may be useful for tools to exploit.
For instance, looking at all the changes to bpf.h since it was last
copied to tools/include brings this to toolers' attention:
Need to investigate this one to check how to run a program via perf, setting up
a BPF event, that will take advantage of the way perf already calls clang/LLVM,
sets up the event and runs the workload in a single command line, helping in
debugging such semi cooperative programs:
96ae52279594 ("bpf: Add bpf_probe_write_user BPF helper to be called in tracers")
This one needs further investigation about using the feature it improves
in 'perf trace' to do some tcpdumpin' mixed with syscalls, tracepoints,
probe points, callgraphs, etc:
555c8a8623a3 ("bpf: avoid stack copy and use skb ctx for event output")
Add tracing just packets that are related to some container to that mix:
4a482f34afcc ("cgroup: bpf: Add bpf_skb_in_cgroup_proto")
4ed8ec521ed5 ("cgroup: bpf: Add BPF_MAP_TYPE_CGROUP_ARRAY")
Definetely needs to have example programs accessing task_struct from a bpf proggie
started from 'perf trace':
606274c5abd8 ("bpf: introduce bpf_get_current_task() helper")
Core networking related, XDP:
6ce96ca348a9 ("bpf: add XDP_TX xdp_action for direct forwarding")
6a773a15a1e8 ("bpf: add XDP prog type for early driver filter")
13c5c240f789 ("bpf: add bpf_get_hash_recalc helper")
d2485c4242a8 ("bpf: add bpf_skb_change_type helper")
6578171a7ff0 ("bpf: add bpf_skb_change_proto helper")
Changes detected by the tools build system:
$ make -C tools/perf O=/tmp/build/perf install-bin
make: Entering directory '/home/acme/git/linux/tools/perf'
BUILD: Doing 'make -j4' parallel build
Warning: tools/include/uapi/linux/bpf.h differs from kernel
INSTALL GTK UI
CC /tmp/build/perf/bench/mem-memcpy-x86-64-asm.o
<SNIP>
$
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexei Starovoitov <ast@fb.com>
Cc: Brenden Blanco <bblanco@plumgrid.com>
Cc: Daniel Borkmann <daniel@iogearbox.net>
Cc: David Ahern <dsahern@gmail.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Martin KaFai Lau <kafai@fb.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Sargun Dhillon <sargun@sargun.me>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/n/tip-difq4ts1xvww6eyfs9e7zlft@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-08-09 14:48:07 +00:00
|
|
|
/* User return codes for XDP prog type.
|
|
|
|
|
* A valid XDP program must return one of these defined values. All other
|
2017-09-25 00:25:52 +00:00
|
|
|
* return codes are reserved for future use. Unknown return codes will
|
|
|
|
|
* result in packet drops and a warning via bpf_warn_invalid_xdp_action().
|
toops: Sync tools/include/uapi/linux/bpf.h with the kernel
The way we're using kernel headers in tools/ now, with a copy that is
made to the same path prefixed by "tools/" plus checking if that copy
got stale, i.e. if the kernel counterpart changed, helps in keeping
track with new features that may be useful for tools to exploit.
For instance, looking at all the changes to bpf.h since it was last
copied to tools/include brings this to toolers' attention:
Need to investigate this one to check how to run a program via perf, setting up
a BPF event, that will take advantage of the way perf already calls clang/LLVM,
sets up the event and runs the workload in a single command line, helping in
debugging such semi cooperative programs:
96ae52279594 ("bpf: Add bpf_probe_write_user BPF helper to be called in tracers")
This one needs further investigation about using the feature it improves
in 'perf trace' to do some tcpdumpin' mixed with syscalls, tracepoints,
probe points, callgraphs, etc:
555c8a8623a3 ("bpf: avoid stack copy and use skb ctx for event output")
Add tracing just packets that are related to some container to that mix:
4a482f34afcc ("cgroup: bpf: Add bpf_skb_in_cgroup_proto")
4ed8ec521ed5 ("cgroup: bpf: Add BPF_MAP_TYPE_CGROUP_ARRAY")
Definetely needs to have example programs accessing task_struct from a bpf proggie
started from 'perf trace':
606274c5abd8 ("bpf: introduce bpf_get_current_task() helper")
Core networking related, XDP:
6ce96ca348a9 ("bpf: add XDP_TX xdp_action for direct forwarding")
6a773a15a1e8 ("bpf: add XDP prog type for early driver filter")
13c5c240f789 ("bpf: add bpf_get_hash_recalc helper")
d2485c4242a8 ("bpf: add bpf_skb_change_type helper")
6578171a7ff0 ("bpf: add bpf_skb_change_proto helper")
Changes detected by the tools build system:
$ make -C tools/perf O=/tmp/build/perf install-bin
make: Entering directory '/home/acme/git/linux/tools/perf'
BUILD: Doing 'make -j4' parallel build
Warning: tools/include/uapi/linux/bpf.h differs from kernel
INSTALL GTK UI
CC /tmp/build/perf/bench/mem-memcpy-x86-64-asm.o
<SNIP>
$
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexei Starovoitov <ast@fb.com>
Cc: Brenden Blanco <bblanco@plumgrid.com>
Cc: Daniel Borkmann <daniel@iogearbox.net>
Cc: David Ahern <dsahern@gmail.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Martin KaFai Lau <kafai@fb.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Sargun Dhillon <sargun@sargun.me>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/n/tip-difq4ts1xvww6eyfs9e7zlft@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-08-09 14:48:07 +00:00
|
|
|
*/
|
|
|
|
|
enum xdp_action {
|
|
|
|
|
XDP_ABORTED = 0,
|
|
|
|
|
XDP_DROP,
|
|
|
|
|
XDP_PASS,
|
|
|
|
|
XDP_TX,
|
2017-09-25 00:25:52 +00:00
|
|
|
XDP_REDIRECT,
|
toops: Sync tools/include/uapi/linux/bpf.h with the kernel
The way we're using kernel headers in tools/ now, with a copy that is
made to the same path prefixed by "tools/" plus checking if that copy
got stale, i.e. if the kernel counterpart changed, helps in keeping
track with new features that may be useful for tools to exploit.
For instance, looking at all the changes to bpf.h since it was last
copied to tools/include brings this to toolers' attention:
Need to investigate this one to check how to run a program via perf, setting up
a BPF event, that will take advantage of the way perf already calls clang/LLVM,
sets up the event and runs the workload in a single command line, helping in
debugging such semi cooperative programs:
96ae52279594 ("bpf: Add bpf_probe_write_user BPF helper to be called in tracers")
This one needs further investigation about using the feature it improves
in 'perf trace' to do some tcpdumpin' mixed with syscalls, tracepoints,
probe points, callgraphs, etc:
555c8a8623a3 ("bpf: avoid stack copy and use skb ctx for event output")
Add tracing just packets that are related to some container to that mix:
4a482f34afcc ("cgroup: bpf: Add bpf_skb_in_cgroup_proto")
4ed8ec521ed5 ("cgroup: bpf: Add BPF_MAP_TYPE_CGROUP_ARRAY")
Definetely needs to have example programs accessing task_struct from a bpf proggie
started from 'perf trace':
606274c5abd8 ("bpf: introduce bpf_get_current_task() helper")
Core networking related, XDP:
6ce96ca348a9 ("bpf: add XDP_TX xdp_action for direct forwarding")
6a773a15a1e8 ("bpf: add XDP prog type for early driver filter")
13c5c240f789 ("bpf: add bpf_get_hash_recalc helper")
d2485c4242a8 ("bpf: add bpf_skb_change_type helper")
6578171a7ff0 ("bpf: add bpf_skb_change_proto helper")
Changes detected by the tools build system:
$ make -C tools/perf O=/tmp/build/perf install-bin
make: Entering directory '/home/acme/git/linux/tools/perf'
BUILD: Doing 'make -j4' parallel build
Warning: tools/include/uapi/linux/bpf.h differs from kernel
INSTALL GTK UI
CC /tmp/build/perf/bench/mem-memcpy-x86-64-asm.o
<SNIP>
$
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexei Starovoitov <ast@fb.com>
Cc: Brenden Blanco <bblanco@plumgrid.com>
Cc: Daniel Borkmann <daniel@iogearbox.net>
Cc: David Ahern <dsahern@gmail.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Martin KaFai Lau <kafai@fb.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Sargun Dhillon <sargun@sargun.me>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/n/tip-difq4ts1xvww6eyfs9e7zlft@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-08-09 14:48:07 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* user accessible metadata for XDP packet hook
|
|
|
|
|
* new fields must be added to the end of this structure
|
|
|
|
|
*/
|
|
|
|
|
struct xdp_md {
|
|
|
|
|
__u32 data;
|
|
|
|
|
__u32 data_end;
|
2017-09-25 00:25:52 +00:00
|
|
|
__u32 data_meta;
|
2018-01-18 16:49:08 +00:00
|
|
|
/* Below access go through struct xdp_rxq_info */
|
|
|
|
|
__u32 ingress_ifindex; /* rxq->dev->ifindex */
|
|
|
|
|
__u32 rx_queue_index; /* rxq->queue_index */
|
toops: Sync tools/include/uapi/linux/bpf.h with the kernel
The way we're using kernel headers in tools/ now, with a copy that is
made to the same path prefixed by "tools/" plus checking if that copy
got stale, i.e. if the kernel counterpart changed, helps in keeping
track with new features that may be useful for tools to exploit.
For instance, looking at all the changes to bpf.h since it was last
copied to tools/include brings this to toolers' attention:
Need to investigate this one to check how to run a program via perf, setting up
a BPF event, that will take advantage of the way perf already calls clang/LLVM,
sets up the event and runs the workload in a single command line, helping in
debugging such semi cooperative programs:
96ae52279594 ("bpf: Add bpf_probe_write_user BPF helper to be called in tracers")
This one needs further investigation about using the feature it improves
in 'perf trace' to do some tcpdumpin' mixed with syscalls, tracepoints,
probe points, callgraphs, etc:
555c8a8623a3 ("bpf: avoid stack copy and use skb ctx for event output")
Add tracing just packets that are related to some container to that mix:
4a482f34afcc ("cgroup: bpf: Add bpf_skb_in_cgroup_proto")
4ed8ec521ed5 ("cgroup: bpf: Add BPF_MAP_TYPE_CGROUP_ARRAY")
Definetely needs to have example programs accessing task_struct from a bpf proggie
started from 'perf trace':
606274c5abd8 ("bpf: introduce bpf_get_current_task() helper")
Core networking related, XDP:
6ce96ca348a9 ("bpf: add XDP_TX xdp_action for direct forwarding")
6a773a15a1e8 ("bpf: add XDP prog type for early driver filter")
13c5c240f789 ("bpf: add bpf_get_hash_recalc helper")
d2485c4242a8 ("bpf: add bpf_skb_change_type helper")
6578171a7ff0 ("bpf: add bpf_skb_change_proto helper")
Changes detected by the tools build system:
$ make -C tools/perf O=/tmp/build/perf install-bin
make: Entering directory '/home/acme/git/linux/tools/perf'
BUILD: Doing 'make -j4' parallel build
Warning: tools/include/uapi/linux/bpf.h differs from kernel
INSTALL GTK UI
CC /tmp/build/perf/bench/mem-memcpy-x86-64-asm.o
<SNIP>
$
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexei Starovoitov <ast@fb.com>
Cc: Brenden Blanco <bblanco@plumgrid.com>
Cc: Daniel Borkmann <daniel@iogearbox.net>
Cc: David Ahern <dsahern@gmail.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Martin KaFai Lau <kafai@fb.com>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Sargun Dhillon <sargun@sargun.me>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/n/tip-difq4ts1xvww6eyfs9e7zlft@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2016-08-09 14:48:07 +00:00
|
|
|
};
|
|
|
|
|
|
2017-08-16 05:33:32 +00:00
|
|
|
enum sk_action {
|
2017-10-27 16:45:53 +00:00
|
|
|
SK_DROP = 0,
|
|
|
|
|
SK_PASS,
|
2017-08-16 05:33:32 +00:00
|
|
|
};
|
|
|
|
|
|
2017-06-05 19:15:53 +00:00
|
|
|
#define BPF_TAG_SIZE 8
|
|
|
|
|
|
|
|
|
|
struct bpf_prog_info {
|
|
|
|
|
__u32 type;
|
|
|
|
|
__u32 id;
|
|
|
|
|
__u8 tag[BPF_TAG_SIZE];
|
|
|
|
|
__u32 jited_prog_len;
|
|
|
|
|
__u32 xlated_prog_len;
|
|
|
|
|
__aligned_u64 jited_prog_insns;
|
|
|
|
|
__aligned_u64 xlated_prog_insns;
|
2017-09-27 21:37:54 +00:00
|
|
|
__u64 load_time; /* ns since boottime */
|
|
|
|
|
__u32 created_by_uid;
|
|
|
|
|
__u32 nr_map_ids;
|
|
|
|
|
__aligned_u64 map_ids;
|
2017-10-22 17:29:06 +00:00
|
|
|
char name[BPF_OBJ_NAME_LEN];
|
2017-12-28 02:39:09 +00:00
|
|
|
__u32 ifindex;
|
|
|
|
|
__u64 netns_dev;
|
|
|
|
|
__u64 netns_ino;
|
2017-06-05 19:15:53 +00:00
|
|
|
} __attribute__((aligned(8)));
|
|
|
|
|
|
|
|
|
|
struct bpf_map_info {
|
|
|
|
|
__u32 type;
|
|
|
|
|
__u32 id;
|
|
|
|
|
__u32 key_size;
|
|
|
|
|
__u32 value_size;
|
|
|
|
|
__u32 max_entries;
|
|
|
|
|
__u32 map_flags;
|
2017-10-06 04:52:12 +00:00
|
|
|
char name[BPF_OBJ_NAME_LEN];
|
2018-01-18 03:13:28 +00:00
|
|
|
__u32 ifindex;
|
|
|
|
|
__u64 netns_dev;
|
|
|
|
|
__u64 netns_ino;
|
2017-06-05 19:15:53 +00:00
|
|
|
} __attribute__((aligned(8)));
|
|
|
|
|
|
2017-07-01 03:02:55 +00:00
|
|
|
/* User bpf_sock_ops struct to access socket values and specify request ops
|
|
|
|
|
* and their replies.
|
2017-07-31 13:45:07 +00:00
|
|
|
* Some of this fields are in network (bigendian) byte order and may need
|
|
|
|
|
* to be converted before use (bpf_ntohl() defined in samples/bpf/bpf_endian.h).
|
2017-07-01 03:02:55 +00:00
|
|
|
* New fields can only be added at the end of this structure
|
|
|
|
|
*/
|
|
|
|
|
struct bpf_sock_ops {
|
|
|
|
|
__u32 op;
|
|
|
|
|
union {
|
2018-01-26 00:14:16 +00:00
|
|
|
__u32 args[4]; /* Optionally passed to bpf program */
|
|
|
|
|
__u32 reply; /* Returned by bpf program */
|
|
|
|
|
__u32 replylong[4]; /* Optionally returned by bpf prog */
|
2017-07-01 03:02:55 +00:00
|
|
|
};
|
|
|
|
|
__u32 family;
|
2017-07-31 13:45:07 +00:00
|
|
|
__u32 remote_ip4; /* Stored in network byte order */
|
|
|
|
|
__u32 local_ip4; /* Stored in network byte order */
|
|
|
|
|
__u32 remote_ip6[4]; /* Stored in network byte order */
|
|
|
|
|
__u32 local_ip6[4]; /* Stored in network byte order */
|
|
|
|
|
__u32 remote_port; /* Stored in network byte order */
|
|
|
|
|
__u32 local_port; /* stored in host byte order */
|
2018-01-18 16:49:08 +00:00
|
|
|
__u32 is_fullsock; /* Some TCP fields are only valid if
|
|
|
|
|
* there is a full socket. If not, the
|
|
|
|
|
* fields read as zero.
|
|
|
|
|
*/
|
|
|
|
|
__u32 snd_cwnd;
|
|
|
|
|
__u32 srtt_us; /* Averaged RTT << 3 in usecs */
|
2018-01-26 00:14:16 +00:00
|
|
|
__u32 bpf_sock_ops_cb_flags; /* flags defined in uapi/linux/tcp.h */
|
|
|
|
|
__u32 state;
|
|
|
|
|
__u32 rtt_min;
|
|
|
|
|
__u32 snd_ssthresh;
|
|
|
|
|
__u32 rcv_nxt;
|
|
|
|
|
__u32 snd_nxt;
|
|
|
|
|
__u32 snd_una;
|
|
|
|
|
__u32 mss_cache;
|
|
|
|
|
__u32 ecn_flags;
|
|
|
|
|
__u32 rate_delivered;
|
|
|
|
|
__u32 rate_interval_us;
|
|
|
|
|
__u32 packets_out;
|
|
|
|
|
__u32 retrans_out;
|
|
|
|
|
__u32 total_retrans;
|
|
|
|
|
__u32 segs_in;
|
|
|
|
|
__u32 data_segs_in;
|
|
|
|
|
__u32 segs_out;
|
|
|
|
|
__u32 data_segs_out;
|
|
|
|
|
__u32 lost_out;
|
|
|
|
|
__u32 sacked_out;
|
|
|
|
|
__u32 sk_txhash;
|
|
|
|
|
__u64 bytes_received;
|
|
|
|
|
__u64 bytes_acked;
|
2017-07-01 03:02:55 +00:00
|
|
|
};
|
|
|
|
|
|
2018-01-26 00:14:16 +00:00
|
|
|
/* Definitions for bpf_sock_ops_cb_flags */
|
|
|
|
|
#define BPF_SOCK_OPS_RTO_CB_FLAG (1<<0)
|
|
|
|
|
#define BPF_SOCK_OPS_RETRANS_CB_FLAG (1<<1)
|
|
|
|
|
#define BPF_SOCK_OPS_STATE_CB_FLAG (1<<2)
|
|
|
|
|
#define BPF_SOCK_OPS_ALL_CB_FLAGS 0x7 /* Mask of all currently
|
|
|
|
|
* supported cb flags
|
|
|
|
|
*/
|
|
|
|
|
|
2017-07-01 03:02:55 +00:00
|
|
|
/* List of known BPF sock_ops operators.
|
|
|
|
|
* New entries can only be added at the end
|
|
|
|
|
*/
|
|
|
|
|
enum {
|
|
|
|
|
BPF_SOCK_OPS_VOID,
|
|
|
|
|
BPF_SOCK_OPS_TIMEOUT_INIT, /* Should return SYN-RTO value to use or
|
|
|
|
|
* -1 if default value should be used
|
|
|
|
|
*/
|
|
|
|
|
BPF_SOCK_OPS_RWND_INIT, /* Should return initial advertized
|
|
|
|
|
* window (in packets) or -1 if default
|
|
|
|
|
* value should be used
|
|
|
|
|
*/
|
|
|
|
|
BPF_SOCK_OPS_TCP_CONNECT_CB, /* Calls BPF program right before an
|
|
|
|
|
* active connection is initialized
|
|
|
|
|
*/
|
|
|
|
|
BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB, /* Calls BPF program when an
|
|
|
|
|
* active connection is
|
|
|
|
|
* established
|
|
|
|
|
*/
|
|
|
|
|
BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB, /* Calls BPF program when a
|
|
|
|
|
* passive connection is
|
|
|
|
|
* established
|
|
|
|
|
*/
|
|
|
|
|
BPF_SOCK_OPS_NEEDS_ECN, /* If connection's congestion control
|
|
|
|
|
* needs ECN
|
|
|
|
|
*/
|
2017-10-22 17:29:06 +00:00
|
|
|
BPF_SOCK_OPS_BASE_RTT, /* Get base RTT. The correct value is
|
|
|
|
|
* based on the path and may be
|
|
|
|
|
* dependent on the congestion control
|
|
|
|
|
* algorithm. In general it indicates
|
|
|
|
|
* a congestion threshold. RTTs above
|
|
|
|
|
* this indicate congestion
|
|
|
|
|
*/
|
2018-01-26 00:14:16 +00:00
|
|
|
BPF_SOCK_OPS_RTO_CB, /* Called when an RTO has triggered.
|
|
|
|
|
* Arg1: value of icsk_retransmits
|
|
|
|
|
* Arg2: value of icsk_rto
|
|
|
|
|
* Arg3: whether RTO has expired
|
|
|
|
|
*/
|
|
|
|
|
BPF_SOCK_OPS_RETRANS_CB, /* Called when skb is retransmitted.
|
|
|
|
|
* Arg1: sequence number of 1st byte
|
|
|
|
|
* Arg2: # segments
|
|
|
|
|
* Arg3: return value of
|
|
|
|
|
* tcp_transmit_skb (0 => success)
|
|
|
|
|
*/
|
|
|
|
|
BPF_SOCK_OPS_STATE_CB, /* Called when TCP changes state.
|
|
|
|
|
* Arg1: old_state
|
|
|
|
|
* Arg2: new_state
|
|
|
|
|
*/
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* List of TCP states. There is a build check in net/ipv4/tcp.c to detect
|
|
|
|
|
* changes between the TCP and BPF versions. Ideally this should never happen.
|
|
|
|
|
* If it does, we need to add code to convert them before calling
|
|
|
|
|
* the BPF sock_ops function.
|
|
|
|
|
*/
|
|
|
|
|
enum {
|
|
|
|
|
BPF_TCP_ESTABLISHED = 1,
|
|
|
|
|
BPF_TCP_SYN_SENT,
|
|
|
|
|
BPF_TCP_SYN_RECV,
|
|
|
|
|
BPF_TCP_FIN_WAIT1,
|
|
|
|
|
BPF_TCP_FIN_WAIT2,
|
|
|
|
|
BPF_TCP_TIME_WAIT,
|
|
|
|
|
BPF_TCP_CLOSE,
|
|
|
|
|
BPF_TCP_CLOSE_WAIT,
|
|
|
|
|
BPF_TCP_LAST_ACK,
|
|
|
|
|
BPF_TCP_LISTEN,
|
|
|
|
|
BPF_TCP_CLOSING, /* Now a valid state */
|
|
|
|
|
BPF_TCP_NEW_SYN_RECV,
|
|
|
|
|
|
|
|
|
|
BPF_TCP_MAX_STATES /* Leave at the end! */
|
2017-07-01 03:02:55 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define TCP_BPF_IW 1001 /* Set TCP initial congestion window */
|
|
|
|
|
#define TCP_BPF_SNDCWND_CLAMP 1002 /* Set sndcwnd_clamp */
|
|
|
|
|
|
2017-10-22 17:29:06 +00:00
|
|
|
struct bpf_perf_event_value {
|
|
|
|
|
__u64 counter;
|
|
|
|
|
__u64 enabled;
|
|
|
|
|
__u64 running;
|
|
|
|
|
};
|
|
|
|
|
|
2017-11-05 13:15:32 +00:00
|
|
|
#define BPF_DEVCG_ACC_MKNOD (1ULL << 0)
|
|
|
|
|
#define BPF_DEVCG_ACC_READ (1ULL << 1)
|
|
|
|
|
#define BPF_DEVCG_ACC_WRITE (1ULL << 2)
|
|
|
|
|
|
|
|
|
|
#define BPF_DEVCG_DEV_BLOCK (1ULL << 0)
|
|
|
|
|
#define BPF_DEVCG_DEV_CHAR (1ULL << 1)
|
|
|
|
|
|
|
|
|
|
struct bpf_cgroup_dev_ctx {
|
2018-01-18 16:49:08 +00:00
|
|
|
/* access_type encoded as (BPF_DEVCG_ACC_* << 16) | BPF_DEVCG_DEV_* */
|
|
|
|
|
__u32 access_type;
|
2017-11-05 13:15:32 +00:00
|
|
|
__u32 major;
|
|
|
|
|
__u32 minor;
|
|
|
|
|
};
|
|
|
|
|
|
2016-07-11 19:38:05 +00:00
|
|
|
#endif /* _UAPI__LINUX_BPF_H__ */
|