bpf: add netfilter program type
Subsystems (10)
Florian Westphal
maintainerv3 cover bpf: add netfilter program type
Add minimal support to hook bpf programs to netfilter hooks, e.g. PREROUTING or FORWARD.
For this the most relevant parts for registering a netfilter hook via the in-kernel api are exposed to userspace via bpf_link.
The new program type is 'tracing style', i.e. there is no context access rewrite done by verifier, the function argument (struct bpf_nf_ctx) isn't stable.
There is no support for direct packet access, dynptr api should be used instead.
With this its possible to build a small test program such as:
#include "vmlinux.h"
extern int bpf_dynptr_from_skb(struct __sk_buff *skb, __u64 flags,
struct bpf_dynptr *ptr__uninit) __ksym;
extern void *bpf_dynptr_slice(const struct bpf_dynptr *ptr, uint32_t offset,
void *buffer, uint32_t buffer__sz) __ksym;
SEC("netfilter")
int nf_test(struct bpf_nf_ctx *ctx)
{
struct nf_hook_state *state = ctx->state;
struct sk_buff *skb = ctx->skb;
const struct iphdr *iph, _iph;
const struct tcphdr *th, _th;
struct bpf_dynptr ptr;
if (bpf_dynptr_from_skb(skb, 0, &ptr))
return NF_DROP;
iph = bpf_dynptr_slice(&ptr, 0, &_iph, sizeof(_iph));
if (!iph)
return NF_DROP;
th = bpf_dynptr_slice(&ptr, iph->ihl << 2, &_th, sizeof(_th));
if (!th)
return NF_DROP;
bpf_printk("accept %x:%d->%x:%d, hook %d ifin %d\n", iph->saddr, bpf_ntohs(th->source), iph->daddr, bpf_ntohs(th->dest), state->hook, state->in->ifindex);
return NF_ACCEPT;
}Then, tail /sys/kernel/tracing/trace_pipe.
Changes since v2:
1. don't WARN when user calls 'bpftool loink detach' twice restrict attachment to ip+ip6 families, lets relax this later in case arp/bridge/netdev are needed too.
2. show netfilter links in 'bpftool net' output as well.
Changes since v1:
1. Don't fail to link when CONFIG_NETFILTER=n (build bot)
2. Use test_progs instead of test_verifier (Alexei)
Changes since last RFC version:
1. extend 'bpftool link show' to print prio/hooknum etc
2. extend 'nft list hooks' so it can print the bpf program id
3. Add an extra patch to artificially restrict bpf progs with same priority. Its fine from a technical pov but it will cause ordering issues (most recent one comes first). Can be removed later.
4. Add test_run support for netfilter prog type and a small extension to verifier tests to make sure we can't return verdicts like NF_STOLEN.
5. Alter the netfilter part of the bpf_link uapi struct:
- add flags/reserved members.
Not used here except returning errors when they are nonzero. Plan is to allow the bpf_link users to enable netfilter defrag or conntrack engine by setting feature flags at link create time in the future.
Let me know if there is anything missing that has to be addressed before this can be merged.
Florian Westphal (6):
bpf: add bpf_link support for BPF_NETFILTER programs
bpf: minimal support for programs hooked into netfilter framework
netfilter: nfnetlink hook: dump bpf prog id
netfilter: disallow bpf hook attachment at same priority
tools: bpftool: print netfilter link info
bpf: add test_run support for netfilter program type
include/linux/bpf.h | 3 + include/linux/bpf_types.h | 4 + include/linux/netfilter.h | 1 + include/net/netfilter/nf_bpf_link.h | 15 ++ include/uapi/linux/bpf.h | 15 ++ include/uapi/linux/netfilter/nfnetlink_hook.h | 20 +- kernel/bpf/btf.c | 6 + kernel/bpf/syscall.c | 6 + kernel/bpf/verifier.c | 3 + net/bpf/test_run.c | 140 +++++++++++ net/core/filter.c | 1 + net/netfilter/Kconfig | 3 + net/netfilter/Makefile | 1 + net/netfilter/core.c | 12 + net/netfilter/nf_bpf_link.c | 229 ++++++++++++++++++ net/netfilter/nfnetlink_hook.c | 81 ++++++- tools/bpf/bpftool/link.c | 83 +++++++ tools/bpf/bpftool/main.h | 3 + tools/bpf/bpftool/net.c | 105 ++++++++ tools/include/uapi/linux/bpf.h | 15 ++ tools/lib/bpf/libbpf.c | 2 + .../selftests/bpf/prog_tests/verifier.c | 2 + .../bpf/progs/verifier_netfilter_retcode.c | 49 ++++ 23 files changed, 785 insertions(+), 14 deletions(-) create mode 100644 include/net/netfilter/nf_bpf_link.h create mode 100644 net/netfilter/nf_bpf_link.c create mode 100644 tools/testing/selftests/bpf/progs/verifier_netfilter_retcode.c
Signature · 1 line
2.39.2
Florian Westphal
maintainerPATCH v3 1/6 bpf: add bpf_link support for BPF_NETFILTER programs
Add bpf_link support skeleton. To keep this reviewable, no bpf program can be invoked yet, if a program is attached only a c-stub is called and not the actual bpf program.
Defaults to 'y' if both netfilter and bpf syscall are enabled in kconfig.
Uapi example usage:
union bpf_attr attr = { };
attr.link_create.prog_fd = progfd;
attr.link_create.attach_type = 0; /* unused */
attr.link_create.netfilter.pf = PF_INET;
attr.link_create.netfilter.hooknum = NF_INET_LOCAL_IN;
attr.link_create.netfilter.priority = -128;
err = bpf(BPF_LINK_CREATE, &attr, sizeof(attr));... this would attach progfd to ipv4:input hook.
Such hook gets removed automatically if the calling program exits.
BPF_NETFILTER program invocation is added in followup change.
NF_HOOK_OP_BPF enum will eventually be read from nfnetlink_hook, it allows to tell userspace which program is attached at the given hook when user runs 'nft hook list' command rather than just the priority and not-very-helpful 'this hook runs a bpf prog but I can't tell which one'.
Will also be used to disallow registration of two bpf programs with same priority in a followup patch.
v2:
- add cmpxchg to prevent double-unreg via 'bpftool link detach', (gives WARN splat from netfilter core)
- restrict to ip/ip6 for now, lets lift restrictions later as more use cases pop up (arptables, ebtables, netdev ingress/egress etc).
--- include/linux/netfilter.h | 1 + include/net/netfilter/nf_bpf_link.h | 10 ++ include/uapi/linux/bpf.h | 15 +++ kernel/bpf/syscall.c | 6 ++ net/netfilter/Kconfig | 3 + net/netfilter/Makefile | 1 + net/netfilter/nf_bpf_link.c | 160 ++++++++++++++++++++++++++++ 7 files changed, 196 insertions(+) create mode 100644 include/net/netfilter/nf_bpf_link.h create mode 100644 net/netfilter/nf_bpf_link.c
include/linux/netfilter.h +1 -0
@@ -80,6 +80,7 @@ typedef unsigned int nf_hookfn(void *priv,enum nf_hook_ops_type {NF_HOOK_OP_UNDEFINED ,NF_HOOK_OP_NF_TABLES , +NF_HOOK_OP_BPF , };struct nf_hook_ops {
include/net/netfilter/nf_bpf_link.h new file +10 -0
@@ -0,0 +1,10 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#if IS_ENABLED (CONFIG_NETFILTER_BPF_LINK ) +int bpf_nf_link_attach (const union bpf_attr *attr,struct bpf_prog *prog); +#else +static inline int bpf_nf_link_attach (const union bpf_attr *attr,struct bpf_prog *prog) +{ +return -EOPNOTSUPP ; +} +#endif
include/uapi/linux/bpf.h +15 -0
@@ -986,6 +986,7 @@ enum bpf_prog_type {BPF_PROG_TYPE_LSM ,BPF_PROG_TYPE_SK_LOOKUP ,BPF_PROG_TYPE_SYSCALL ,/* a program that can execute syscalls */ + BPF_PROG_TYPE_NETFILTER, }; enum bpf_attach_type {
@@ -1050,6 +1051,7 @@ enum bpf_link_type {BPF_LINK_TYPE_PERF_EVENT =7 ,BPF_LINK_TYPE_KPROBE_MULTI =8 ,BPF_LINK_TYPE_STRUCT_OPS =9 , +BPF_LINK_TYPE_NETFILTER =10 , MAX_BPF_LINK_TYPE, };
@@ -1560,6 +1562,13 @@ union bpf_attr {*/ __u64 cookie; } tracing; +struct { +__u32 pf; +__u32 hooknum; +__s32 prio; +__u32 flags; +__u64 reserved[2 ]; + } netfilter; }; } link_create;
@@ -6410,6 +6419,12 @@ struct bpf_link_info {struct {__u32 map_id; } struct_ops; +struct { +__u32 pf; +__u32 hooknum; +__s32 priority; +__u32 flags; + } netfilter; }; } __attribute__((aligned(8)));
kernel/bpf/syscall.c +6 -0
@@ -35,6 +35,7 @@#include <linux/rcupdate_trace.h> #include <linux/memcontrol.h> #include <linux/trace_events.h> +#include <net/netfilter/nf_bpf_link.h> #define IS_FD_ARRAY (map) ((map)->map_type == BPF_MAP_TYPE_PERF_EVENT_ARRAY || \ (map)->map_type == BPF_MAP_TYPE_CGROUP_ARRAY || \
@@ -2462,6 +2463,7 @@ static bool is_net_admin_prog_type(enum bpf_prog_type prog_type)case BPF_PROG_TYPE_CGROUP_SYSCTL :case BPF_PROG_TYPE_SOCK_OPS :case BPF_PROG_TYPE_EXT :/* extends any prog */ +case BPF_PROG_TYPE_NETFILTER :return true;case BPF_PROG_TYPE_CGROUP_SKB :/* always unpriv */
@@ -4588,6 +4590,7 @@ static int link_create(union bpf_attr *attr, bpfptr_t uattr)switch (prog->type) {case BPF_PROG_TYPE_EXT : +case BPF_PROG_TYPE_NETFILTER :break ;case BPF_PROG_TYPE_PERF_EVENT :case BPF_PROG_TYPE_TRACEPOINT :
@@ -4654,6 +4657,9 @@ static int link_create(union bpf_attr *attr, bpfptr_t uattr)case BPF_PROG_TYPE_XDP : ret =bpf_xdp_link_attach (attr, prog);break ; +case BPF_PROG_TYPE_NETFILTER : + ret =bpf_nf_link_attach (attr, prog); +break ;#endif case BPF_PROG_TYPE_PERF_EVENT :case BPF_PROG_TYPE_TRACEPOINT :
net/netfilter/Kconfig +3 -0
@@ -30,6 +30,9 @@ config NETFILTER_FAMILY_BRIDGE config NETFILTER_FAMILY_ARP bool +config NETFILTER_BPF_LINK + def_bool BPF_SYSCALL + config NETFILTER_NETLINK_HOOK tristate "Netfilter base hook dump support" depends on NETFILTER_ADVANCED
net/netfilter/Makefile +1 -0
@@ -22,6 +22,7 @@ nf_conntrack-$(CONFIG_DEBUG_INFO_BTF) += nf_conntrack_bpf.o endif obj-$(CONFIG_NETFILTER) = netfilter.o +obj-$(CONFIG_NETFILTER_BPF_LINK) += nf_bpf_link.o obj-$(CONFIG_NETFILTER_NETLINK) += nfnetlink.o obj-$(CONFIG_NETFILTER_NETLINK_ACCT) += nfnetlink_acct.o
net/netfilter/nf_bpf_link.c new file +160 -0
160 lines not on this page · raw message
Signature · 1 line
2.39.2
Re: [PATCH bpf-next v3 1/6] bpf: add bpf_link support for BPF_NETFILTER programs
Quoted 26 lines · Florian Westphal
include/uapi/linux/bpf.h +13
-0@@ -1560,6 +1562,13 @@ union bpf_attr {*/ __u64 cookie; } tracing; +struct { +__u32 pf; +__u32 hooknum; +__s32 prio; +__u32 flags; +__u64 reserved[2 ]; + } netfilter; }; } link_create;@@ -6410,6 +6419,12 @@ struct bpf_link_info {struct {__u32 map_id; } struct_ops; +struct { +__u32 pf; +__u32 hooknum; +__s32 priority; +__u32 flags; + } netfilter; }; } __attribute__((aligned(8)));
...
net/netfilter/nf_bpf_link.c line 124
Quoted 12 lines
net/netfilter/nf_bpf_link.c new file +12
-0+int bpf_nf_link_attach (const union bpf_attr *attr,struct bpf_prog *prog) +{ +struct net *net = current->nsproxy->net_ns; +struct bpf_link_primer link_primer; +struct bpf_nf_link *link; +int err; + +if (attr->link_create.flags) +return -EINVAL ; + +if (attr->link_create.netfilter.reserved[0 ] | attr->link_create.netfilter.reserved[1 ]) +return -EINVAL ;
Why add 'reserved' name that we cannot change later? I think 'flags' is enough.
net/netfilter/nf_bpf_link.c line 141
Quoted 2 lines
net/netfilter/nf_bpf_link.c new file +2
-0+ link->hook_ops.pf = attr->link_create.netfilter.pf; + link->hook_ops.priority = attr->link_create.netfilter.prio;
let's use the same name in both cases ? Either prio or priority. Both sound fine.
Quoted 1 line
net/netfilter/nf_bpf_link.c new file +1
-0+ link->hook_ops.hooknum = attr->link_create.netfilter.hooknum;
Florian Westphal
maintainerRe: [PATCH bpf-next v3 1/6] bpf: add bpf_link support for BPF_NETFILTER programs
Quoted 7 lines · Alexei Starovoitov
Quoted 7 lines
net/netfilter/nf_bpf_link.c new file +7
-0+int bpf_nf_link_attach (const union bpf_attr *attr,struct bpf_prog *prog) +{ +struct net *net = current->nsproxy->net_ns; +struct bpf_link_primer link_primer; +struct bpf_nf_link *link; +int err; +
Quoted 8 lines
net/netfilter/nf_bpf_link.c line 124
Quoted 5 lines
net/netfilter/nf_bpf_link.c new file +5
-0+if (attr->link_create.flags) +return -EINVAL ; + +if (attr->link_create.netfilter.reserved[0 ] | attr->link_create.netfilter.reserved[1 ]) +return -EINVAL ;Why add 'reserved' name that we cannot change later? I think 'flags' is enough.
OK, I'll zap this.
Quoted 4 lines
net/netfilter/nf_bpf_link.c line 141
Quoted 2 lines
net/netfilter/nf_bpf_link.c new file +2
-0+ link->hook_ops.pf = attr->link_create.netfilter.pf; + link->hook_ops.priority = attr->link_create.netfilter.prio;let's use the same name in both cases ? Either prio or priority. Both sound fine.
OK, I'll go with "priority" then because thats what its named in nf_hook_ops structure.
kernel test robot
build botRe: [PATCH bpf-next v3 1/6] bpf: add bpf_link support for BPF_NETFILTER programs
In reply to Florian Westphalkernel test robot noticed the following build errors:
Hi Florian,
kernel test robot noticed the following build errors:
[auto build test ERROR on bpf-next/master]
url: https://github.com/intel-lab-lkp/linux/commits/Florian-Westphal/bpf-add-bpf_link-support-for-BPF_NETFILTER-programs/20230418-211350 base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master patch link: https://lore.kernel.org/r/20230418131038.18054-2-fw%40strlen.de patch subject: [PATCH bpf-next v3 1/6] bpf: add bpf_link support for BPF_NETFILTER programs config: arm-allmodconfig (https://download.01.org/0day-ci/archive/20230419/[email protected]/config) compiler: arm-linux-gnueabi-gcc (GCC) 12.1.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/intel-lab-lkp/linux/commit/13cdccc8c376b453ae0ca2280ec22baa6210b450
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Florian-Westphal/bpf-add-bpf_link-support-for-BPF_NETFILTER-programs/20230418-211350 git checkout 13cdccc8c376b453ae0ca2280ec22baa6210b450
# save the config file
mkdir build_dir && cp config build_dir/.config
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-12.1.0 make.cross W=1 O=build_dir ARCH=arm olddefconfig COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-12.1.0 make.cross W=1 O=build_dir ARCH=arm SHELL=/bin/bash
If you fix the issue, kindly add following tag where applicable
| Reported-by: kernel test robot <[email protected]>
| Link: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All errors (new ones prefixed by >>):
arm-linux-gnueabi-ld: net/netfilter/nf_bpf_link.o: in function `bpf_nf_link_release':
>> nf_bpf_link.c:(.text+0x174): undefined reference to `__bad_cmpxchg'
arm-linux-gnueabi-ld: net/netfilter/nf_bpf_link.o: in function `bpf_nf_link_detach':
nf_bpf_link.c:(.text+0x200): undefined reference to `__bad_cmpxchg'
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests
Florian Westphal
maintainerPATCH v3 2/6 bpf: minimal support for programs hooked into netfilter framework
In reply to Florian WestphalThis adds minimal support for BPF_PROG_TYPE_NETFILTER bpf programs that will be invoked via the NF_HOOK() points in the ip stack.
Invocation incurs an indirect call. This is not a necessity: Its possible to add 'DEFINE_BPF_DISPATCHER(nf_progs)' and handle the program invocation with the same method already done for xdp progs.
This isn't done here to keep the size of this chunk down.
Verifier restricts verdicts to either DROP or ACCEPT.
--- include/linux/bpf_types.h | 4 ++ include/net/netfilter/nf_bpf_link.h | 5 +++ kernel/bpf/btf.c | 6 +++ kernel/bpf/verifier.c | 3 ++ net/core/filter.c | 1 + net/netfilter/nf_bpf_link.c | 70 ++++++++++++++++++++++++++++- 6 files changed, 88 insertions(+), 1 deletion(-)
include/linux/bpf_types.h +4 -0
@@ -79,6 +79,10 @@ BPF_PROG_TYPE(BPF_PROG_TYPE_LSM, lsm,#endif BPF_PROG_TYPE (BPF_PROG_TYPE_SYSCALL , bpf_syscall, void *, void *) +#ifdef CONFIG_NETFILTER +BPF_PROG_TYPE (BPF_PROG_TYPE_NETFILTER , netfilter, + struct bpf_nf_ctx, struct bpf_nf_ctx) +#endif BPF_MAP_TYPE(BPF_MAP_TYPE_ARRAY, array_map_ops)BPF_MAP_TYPE (BPF_MAP_TYPE_PERCPU_ARRAY , percpu_array_map_ops)
include/net/netfilter/nf_bpf_link.h +5 -0
@@ -1,5 +1,10 @@/* SPDX-License-Identifier: GPL-2.0 */ +struct bpf_nf_ctx { +const struct nf_hook_state *state; +struct sk_buff *skb; +}; +#if IS_ENABLED (CONFIG_NETFILTER_BPF_LINK )int bpf_nf_link_attach (const union bpf_attr *attr,struct bpf_prog *prog);#else
kernel/bpf/btf.c +6 -0
@@ -25,6 +25,9 @@#include <linux/bsearch.h> #include <linux/kobject.h> #include <linux/sysfs.h> + +#include <net/netfilter/nf_bpf_link.h> +#include <net/sock.h> #include "../tools/lib/bpf/relo_core.h"
@@ -212,6 +215,7 @@ enum btf_kfunc_hook {BTF_KFUNC_HOOK_SK_SKB ,BTF_KFUNC_HOOK_SOCKET_FILTER ,BTF_KFUNC_HOOK_LWT , +BTF_KFUNC_HOOK_NETFILTER , BTF_KFUNC_HOOK_MAX, };
@@ -7800,6 +7804,8 @@ static int bpf_prog_type_to_kfunc_hook(enum bpf_prog_type prog_type)case BPF_PROG_TYPE_LWT_XMIT :case BPF_PROG_TYPE_LWT_SEG6LOCAL :return BTF_KFUNC_HOOK_LWT ; +case BPF_PROG_TYPE_NETFILTER : +return BTF_KFUNC_HOOK_NETFILTER ;default :return BTF_KFUNC_HOOK_MAX ; }
kernel/bpf/verifier.c +3 -0
@@ -13816,6 +13816,9 @@ static int check_return_code(struct bpf_verifier_env *env) }break ; +case BPF_PROG_TYPE_NETFILTER : + range =tnum_range (NF_DROP ,NF_ACCEPT ); +break ;case BPF_PROG_TYPE_EXT :/* freplace program can return anything as its return value * depends on the to-be-replaced kernel func or bpf program.
net/core/filter.c +1 -0
@@ -11717,6 +11717,7 @@ static int __init bpf_kfunc_init(void) ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_LWT_IN , &bpf_kfunc_set_skb); ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_LWT_XMIT , &bpf_kfunc_set_skb); ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_LWT_SEG6LOCAL , &bpf_kfunc_set_skb); + ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_NETFILTER , &bpf_kfunc_set_skb);return ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_XDP , &bpf_kfunc_set_xdp); }late_initcall (bpf_kfunc_init);
net/netfilter/nf_bpf_link.c +69 -1
84 lines not on this page · raw message
Signature · 1 line
2.39.2
Re: [PATCH bpf-next v3 2/6] bpf: minimal support for programs hooked into netfilter framework
Quoted 149 lines · Florian Westphal
This adds minimal support for
BPF_PROG_TYPE_NETFILTERbpf programs that will be invoked via theNF_HOOK()points in the ip stack.Invocation incurs an indirect call. This is not a necessity: Its possible to add '
DEFINE_BPF_DISPATCHER(nf_progs)' and handle the program invocation with the same method already done for xdp progs.This isn't done here to keep the size of this chunk down.
Verifier restricts verdicts to either DROP or ACCEPT.
Signed-off-by Florian Westphal <[email protected]>--- include/linux/bpf_types.h | 4 ++ include/net/netfilter/nf_bpf_link.h | 5 +++ kernel/bpf/btf.c | 6 +++ kernel/bpf/verifier.c | 3 ++ net/core/filter.c | 1 + net/netfilter/nf_bpf_link.c | 70 ++++++++++++++++++++++++++++- 6 files changed, 88 insertions(+), 1 deletion(-)include/linux/bpf_types.h +4
-0@@ -79,6 +79,10 @@ BPF_PROG_TYPE(BPF_PROG_TYPE_LSM, lsm,#endif BPF_PROG_TYPE (BPF_PROG_TYPE_SYSCALL , bpf_syscall, void *, void *) +#ifdef CONFIG_NETFILTER +BPF_PROG_TYPE (BPF_PROG_TYPE_NETFILTER , netfilter, + struct bpf_nf_ctx, struct bpf_nf_ctx) +#endif BPF_MAP_TYPE(BPF_MAP_TYPE_ARRAY, array_map_ops)BPF_MAP_TYPE (BPF_MAP_TYPE_PERCPU_ARRAY , percpu_array_map_ops)include/net/netfilter/nf_bpf_link.h +5
-0@@ -1,5 +1,10 @@/* SPDX-License-Identifier: GPL-2.0 */ +struct bpf_nf_ctx { +const struct nf_hook_state *state; +struct sk_buff *skb; +}; +#if IS_ENABLED (CONFIG_NETFILTER_BPF_LINK )int bpf_nf_link_attach (const union bpf_attr *attr,struct bpf_prog *prog);#else kernel/bpf/btf.c +6
-0@@ -25,6 +25,9 @@#include <linux/bsearch.h> #include <linux/kobject.h> #include <linux/sysfs.h> + +#include <net/netfilter/nf_bpf_link.h> +#include <net/sock.h> #include "../tools/lib/bpf/relo_core.h" @@ -212,6 +215,7 @@ enum btf_kfunc_hook {BTF_KFUNC_HOOK_SK_SKB ,BTF_KFUNC_HOOK_SOCKET_FILTER ,BTF_KFUNC_HOOK_LWT , +BTF_KFUNC_HOOK_NETFILTER , BTF_KFUNC_HOOK_MAX, };@@ -7800,6 +7804,8 @@ static int bpf_prog_type_to_kfunc_hook(enum bpf_prog_type prog_type)case BPF_PROG_TYPE_LWT_XMIT :case BPF_PROG_TYPE_LWT_SEG6LOCAL :return BTF_KFUNC_HOOK_LWT ; +case BPF_PROG_TYPE_NETFILTER : +return BTF_KFUNC_HOOK_NETFILTER ;default :return BTF_KFUNC_HOOK_MAX ; }kernel/bpf/verifier.c +3
-0@@ -13816,6 +13816,9 @@ static int check_return_code(struct bpf_verifier_env *env) }break ; +case BPF_PROG_TYPE_NETFILTER : + range =tnum_range (NF_DROP ,NF_ACCEPT ); +break ;case BPF_PROG_TYPE_EXT :/* freplace program can return anything as its return value * depends on the to-be-replaced kernel func or bpf program. net/core/filter.c +1
-0@@ -11717,6 +11717,7 @@ static int __init bpf_kfunc_init(void) ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_LWT_IN , &bpf_kfunc_set_skb); ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_LWT_XMIT , &bpf_kfunc_set_skb); ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_LWT_SEG6LOCAL , &bpf_kfunc_set_skb); + ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_NETFILTER , &bpf_kfunc_set_skb);return ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_XDP , &bpf_kfunc_set_xdp); }late_initcall (bpf_kfunc_init);net/netfilter/nf_bpf_link.c +19
-1@@ -1,5 +1,6 @@// SPDX-License-Identifier: GPL-2.0 #include <linux/bpf.h> +#include <linux/filter.h> #include <linux/netfilter.h> #include <net/netfilter/nf_bpf_link.h> @@ -7,7 +8,13 @@static unsigned int nf_hook_run_bpf (void *bpf_prog,struct sk_buff *skb,const struct nf_hook_state *s) { -return NF_ACCEPT ; +const struct bpf_prog *prog = bpf_prog; +struct bpf_nf_ctx ctx = { + .state = s, + .skb = skb, + }; + +return bpf_prog_run (prog, &ctx); }struct bpf_nf_link {@@ -158,3 +165,64 @@ int bpf_nf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog)return bpf_link_settle (&link_primer); } + +const struct bpf_prog_ops netfilter_prog_ops = { +}; + +static bool nf_ptr_to_btf_id (struct bpf_insn_access_aux *info,const char *name) +{ +struct btf *btf; +s32 type_id; + + btf =bpf_get_btf_vmlinux (); +if (IS_ERR_OR_NULL (btf))
net/netfilter/nf_bpf_link.c int bpf_nf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog) · line 188
Quoted 10 lines
net/netfilter/nf_bpf_link.c +10
-0+return false; + + type_id =btf_find_by_name_kind (btf, name,BTF_KIND_STRUCT ); +if (WARN_ON_ONCE (type_id <0 )) +return false; + + info->btf = btf; + info->btf_id = type_id; + info->reg_type =PTR_TO_BTF_ID |PTR_TRUSTED ; +return true;
This can be improved. Instead of run-time search use pre-processed btf_tracing_ids[] approach.
Add sk_buff and nf_hook_state to BTF_TRACING_TYPE_xxx and take btf ids from array.
It can be a follow up,
but since you're respinning anyway please add a selftest for ctx->skb, ctx->state. The patch 6 only validates the return codes.
Quoted 24 lines
net/netfilter/nf_bpf_link.c +24
-0+} + +static bool nf_is_valid_access (int off,int size,enum bpf_access_type type, +const struct bpf_prog *prog, +struct bpf_insn_access_aux *info) +{ +if (off <0 || off >=sizeof (struct bpf_nf_ctx )) +return false; + +if (type ==BPF_WRITE ) +return false; + +switch (off) { + case bpf_ctx_range(struct bpf_nf_ctx, skb): + if (size != sizeof_field(struct bpf_nf_ctx, skb)) +return false; + +return nf_ptr_to_btf_id (info,"sk_buff" ); + case bpf_ctx_range(struct bpf_nf_ctx, state): + if (size != sizeof_field(struct bpf_nf_ctx, state)) +return false; + +return nf_ptr_to_btf_id (info,"nf_hook_state" ); +default :
net/netfilter/nf_bpf_link.c int bpf_nf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog) · line 222
Quoted 10 lines
net/netfilter/nf_bpf_link.c +10
-0+return false; + } + +return false; +} + +static const struct bpf_func_proto * +bpf_nf_func_proto (enum bpf_func_id func_id,const struct bpf_prog *prog) +{ +return bpf_base_func_proto (func_id);
As a next step we probably need to generalize tc_cls_act_func_proto to take trusted ptr_to_btf skb instead of ctx.
netfilter progs should be able to use bpf_skb_load_bytes and friends.
Florian Westphal
maintainerPATCH v3 3/6 netfilter: nfnetlink hook: dump bpf prog id
In reply to Florian WestphalThis allows userspace ("nft list hooks") to show which bpf program is attached to which hook.
Without this, user only knows bpf prog is attached at prio x, y, z at INPUT and FORWARD, but can't tell which program is where.
--- include/uapi/linux/netfilter/nfnetlink_hook.h | 20 ++++- net/netfilter/nfnetlink_hook.c | 81 ++++++++++++++++--- 2 files changed, 87 insertions(+), 14 deletions(-)
include/uapi/linux/netfilter/nfnetlink_hook.h +19 -1
@@ -32,8 +32,12 @@ enum nfnl_hook_attributes {/** * enum nfnl_hook_chain_info_attributes - chain description * -* NFNLA_HOOK_INFO_DESC: nft chain and table name (enum nft_table_attributes) (NLA_NESTED) +* NFNLA_HOOK_INFO_DESC: nft chain and table name (NLA_NESTED) * NFNLA_HOOK_INFO_TYPE: chain type (enum nfnl_hook_chaintype) (NLA_U32) +* +* NFNLA_HOOK_INFO_DESC depends on NFNLA_HOOK_INFO_TYPE value: +* NFNL_HOOK_TYPE_NFTABLES: enum nft_table_attributes +* NFNL_HOOK_TYPE_BPF: enum nfnl_hook_bpf_info_attributes */ enum nfnl_hook_chain_info_attributes {NFNLA_HOOK_INFO_UNSPEC ,
@@ -56,9 +60,23 @@ enum nfnl_hook_chain_desc_attributes {* enum nfnl_hook_chaintype - chain type * * @NFNL_HOOK_TYPE_NFTABLES nf_tables base chain +* @NFNL_HOOK_TYPE_BPF bpf program */ enum nfnl_hook_chaintype {NFNL_HOOK_TYPE_NFTABLES =0x1 , +NFNL_HOOK_TYPE_BPF , +}; + +/** +* enum nfnl_hook_bpf_info_attributes - bpf prog description +* +* NFNLA_BPF_INFO_ID: bpf program id (NLA_U32) +*/ +enum nfnl_hook_bpf_attributes { +NFNLA_HOOK_BPF_UNSPEC , +NFNLA_HOOK_BPF_ID , + __NFNLA_HOOK_BPF_MAX, }; +#define NFNLA_HOOK_BPF_MAX (__NFNLA_HOOK_BPF_MAX - 1)#endif /* _NFNL_HOOK_H */
net/netfilter/nfnetlink_hook.c +68 -13
116 lines not on this page · raw message
Signature · 1 line
2.39.2
Re: [PATCH bpf-next v3 3/6] netfilter: nfnetlink hook: dump bpf prog id
Quoted 7 lines · Florian Westphal
This allows userspace ("nft list hooks") to show which bpf program is attached to which hook.
Without this, user only knows bpf prog is attached at prio x, y, z at INPUT and FORWARD, but can't tell which program is where.
Signed-off-by Florian Westphal <[email protected]>
Hi Florian,
as it seems there will be a v4, some kdoc nits from my side.
Quoted 10 lines
--- include/uapi/linux/netfilter/nfnetlink_hook.h | 20 ++++- net/netfilter/nfnetlink_hook.c | 81 ++++++++++++++++--- 2 files changed, 87 insertions(+), 14 deletions(-)include/uapi/linux/netfilter/nfnetlink_hook.h +0
-0
include/uapi/linux/netfilter/nfnetlink_hook.h enum nfnl_hook_attributes { · line 36
Quoted 6 lines
include/uapi/linux/netfilter/nfnetlink_hook.h +1
-1@@ -32,8 +32,12 @@ enum nfnl_hook_attributes {/** * enum nfnl_hook_chain_info_attributes - chain description * -* NFNLA_HOOK_INFO_DESC: nft chain and table name (enum nft_table_attributes) (NLA_NESTED) +* NFNLA_HOOK_INFO_DESC: nft chain and table name (NLA_NESTED) * NFNLA_HOOK_INFO_TYPE: chain type (enum nfnl_hook_chaintype) (NLA_U32)
nit: -,.s/NFLA/@NFLA/
include/uapi/linux/netfilter/nfnetlink_hook.h enum nfnl_hook_chain_desc_attributes { · line 63
Quoted 12 lines
include/uapi/linux/netfilter/nfnetlink_hook.h +5
-0+* +* NFNLA_HOOK_INFO_DESC depends on NFNLA_HOOK_INFO_TYPE value: +* NFNL_HOOK_TYPE_NFTABLES: enum nft_table_attributes +* NFNL_HOOK_TYPE_BPF: enum nfnl_hook_bpf_info_attributes */ enum nfnl_hook_chain_info_attributes {NFNLA_HOOK_INFO_UNSPEC ,@@ -56,9 +60,23 @@ enum nfnl_hook_chain_desc_attributes {* enum nfnl_hook_chaintype - chain type * * @NFNL_HOOK_TYPE_NFTABLES nf_tables base chain +* @NFNL_HOOK_TYPE_BPF bpf program
nit: s/@NFNL_HOOK_TYPE_NFTABLES/@NFNL_HOOK_TYPE_NFTABLES:/
s/@NFNL_HOOK_TYPE_BPF/@NFNL_HOOK_TYPE_BPF:/
include/uapi/linux/netfilter/nfnetlink_hook.h enum nfnl_hook_chain_desc_attributes { · line 71
Quoted 8 lines
include/uapi/linux/netfilter/nfnetlink_hook.h +5
-0*/ enum nfnl_hook_chaintype {NFNL_HOOK_TYPE_NFTABLES =0x1 , +NFNL_HOOK_TYPE_BPF , +}; + +/** +* enum nfnl_hook_bpf_info_attributes - bpf prog description
nit: s/nfnl_hook_bpf_info_attributes/nfnl_hook_bpf_attributes/
include/uapi/linux/netfilter/nfnetlink_hook.h enum nfnl_hook_chain_desc_attributes { · line 73
Quoted 2 lines
include/uapi/linux/netfilter/nfnetlink_hook.h +2
-0+* +* NFNLA_BPF_INFO_ID: bpf program id (NLA_U32)
nit: s/NFNLA_BPF_INFO_ID:/NFNLA_HOOK_BPF_ID:/
Quoted 7 lines
include/uapi/linux/netfilter/nfnetlink_hook.h +6
-0+*/ +enum nfnl_hook_bpf_attributes { +NFNLA_HOOK_BPF_UNSPEC , +NFNLA_HOOK_BPF_ID , + __NFNLA_HOOK_BPF_MAX, }; +#define NFNLA_HOOK_BPF_MAX (__NFNLA_HOOK_BPF_MAX - 1)
...
Florian Westphal
maintainerPATCH v3 4/6 netfilter: disallow bpf hook attachment at same priority
In reply to Florian WestphalThis is just to avoid ordering issues between multiple bpf programs, this could be removed later in case it turns out to be too cautious.
bpf prog could still be shared with non-bpf hook, otherwise we'd have to make conntrack hook registration fail just because a bpf program has same priority.
--- net/netfilter/core.c | 12 ++++++++++++ 1 file changed, 12 insertions(+)
net/netfilter/core.c +12 -0
@@ -119,6 +119,18 @@ nf_hook_entries_grow(const struct nf_hook_entries *old,for (i =0 ; i < old_entries; i++) {if (orig_ops[i] != &dummy_ops) alloc_entries++; + +/* Restrict BPF hook type to force a unique priority, not +* shared at attach time. +* +* This is mainly to avoid ordering issues between two +* different bpf programs, this doesn't prevent a normal +* hook at same priority as a bpf one (we don't want to +* prevent defrag, conntrack, iptables etc from attaching). +*/ +if (reg->priority == orig_ops[i]->priority && + reg->hook_ops_type ==NF_HOOK_OP_BPF ) +return ERR_PTR (-EBUSY ); } }
Signature · 1 line
2.39.2
Florian Westphal
maintainerPATCH v3 5/6 tools: bpftool: print netfilter link info
In reply to Florian WestphalDump protocol family, hook and priority value:
$ bpftool link
2: netfilter prog 14
ip input prio -128
pids install(3264)
5: netfilter prog 14
ip6 forward prio 21
pids a.out(3387)
9: netfilter prog 14
ip prerouting prio 123
pids a.out(5700)
10: netfilter prog 14
ip input prio 21
pids test2(5701)v2: Quentin Monnet suggested to also add 'bpftool net' support:
$ bpftool net xdp:
tc:
flow_dissector:
netfilter:
ip prerouting prio 21 prog_id 14
ip input prio -128 prog_id 14
ip input prio 21 prog_id 14
ip forward prio 21 prog_id 14
ip output prio 21 prog_id 14
ip postrouting prio 21 prog_id 14
'bpftool net' only dumps netfilter link type. netfilter links are sorted by protocol family, hook and priority.
--- tools/bpf/bpftool/link.c | 83 ++++++++++++++++++++++++++ tools/bpf/bpftool/main.h | 3 + tools/bpf/bpftool/net.c | 105 +++++++++++++++++++++++++++++++++ tools/include/uapi/linux/bpf.h | 15 +++++ tools/lib/bpf/libbpf.c | 2 + 5 files changed, 208 insertions(+)
tools/bpf/bpftool/link.c +83 -0
@@ -3,6 +3,8 @@#include <errno.h> #include <linux/err.h> +#include <linux/netfilter.h> +#include <linux/netfilter_arp.h> #include <net/if.h> #include <stdio.h> #include <unistd.h>
@@ -135,6 +137,18 @@ static void show_iter_json(struct bpf_link_info *info, json_writer_t *wtr) } } +void netfilter_dump_json (const struct bpf_link_info *info,json_writer_t *wtr) +{ +jsonw_uint_field (json_wtr,"pf" , + info->netfilter.pf); +jsonw_uint_field (json_wtr,"hook" , + info->netfilter.hooknum); +jsonw_int_field (json_wtr,"prio" , + info->netfilter.priority); +jsonw_uint_field (json_wtr,"flags" , + info->netfilter.flags); +} +static int get_prog_info (int prog_id,struct bpf_prog_info *info) {__u32 len =sizeof (*info);
@@ -195,6 +209,10 @@ static int show_link_close_json(int fd, struct bpf_link_info *info) info->netns.netns_ino);show_link_attach_type_json (info->netns.attach_type, json_wtr);break ; +case BPF_LINK_TYPE_NETFILTER : +netfilter_dump_json (info, json_wtr); +break ; +default :break ; }
@@ -263,6 +281,68 @@ static void show_iter_plain(struct bpf_link_info *info) } } +static const char *pf2name[] = { + [NFPROTO_INET ] ="inet" , + [NFPROTO_IPV4 ] ="ip" , + [NFPROTO_ARP ] ="arp" , + [NFPROTO_NETDEV ] ="netdev" , + [NFPROTO_BRIDGE ] ="bridge" , + [NFPROTO_IPV6 ] ="ip6" , +}; + +static const char *inethook2name[] = { + [NF_INET_PRE_ROUTING ] ="prerouting" , + [NF_INET_LOCAL_IN ] ="input" , + [NF_INET_FORWARD ] ="forward" , + [NF_INET_LOCAL_OUT ] ="output" , + [NF_INET_POST_ROUTING ] ="postrouting" , +}; + +static const char *arphook2name[] = { + [NF_ARP_IN ] ="input" , + [NF_ARP_OUT ] ="output" , +}; + +void netfilter_dump_plain (const struct bpf_link_info *info) +{ +const char *hookname =NULL , *pfname =NULL ; +unsigned int hook = info->netfilter.hooknum; +unsigned int pf = info->netfilter.pf; + +if (pf <ARRAY_SIZE (pf2name)) + pfname = pf2name[pf]; + +switch (pf) { +case NFPROTO_BRIDGE :/* bridge shares numbers with enum nf_inet_hooks */ +case NFPROTO_IPV4 : +case NFPROTO_IPV6 : +case NFPROTO_INET : +if (hook <ARRAY_SIZE (inethook2name)) + hookname = inethook2name[hook]; +break ; +case NFPROTO_ARP : +if (hook <ARRAY_SIZE (arphook2name)) + hookname = arphook2name[hook]; +default : +break ; + } + +if (pfname) +printf ("\n\t%s" , pfname); +else +printf ("\n\tpf: %d" , pf); + +if (hookname) +printf (" %s" , hookname); +else +printf (", hook %u," , hook); + +printf (" prio %d" , info->netfilter.priority); + +if (info->netfilter.flags) +printf (" flags 0x%x" , info->netfilter.flags); +} +static int show_link_close_plain (int fd,struct bpf_link_info *info) {struct bpf_prog_info prog_info;
@@ -301,6 +381,9 @@ static int show_link_close_plain(int fd, struct bpf_link_info *info)printf ("\n\tnetns_ino %u " , info->netns.netns_ino);show_link_attach_type_plain (info->netns.attach_type);break ; +case BPF_LINK_TYPE_NETFILTER : +netfilter_dump_plain (info); +break ;default :break ; }
tools/bpf/bpftool/main.h +3 -0
@@ -264,4 +264,7 @@ static inline bool hashmap__empty(struct hashmap *map) return map ? hashmap__size(map) == 0 : true; } +/* print netfilter bpf_link info */ +void netfilter_dump_plain (const struct bpf_link_info *info); +void netfilter_dump_json (const struct bpf_link_info *info,json_writer_t *wtr);#endif
tools/bpf/bpftool/net.c +105 -0
117 lines not on this page · raw message
tools/include/uapi/linux/bpf.h +15 -0
@@ -986,6 +986,7 @@ enum bpf_prog_type {BPF_PROG_TYPE_LSM ,BPF_PROG_TYPE_SK_LOOKUP ,BPF_PROG_TYPE_SYSCALL ,/* a program that can execute syscalls */ + BPF_PROG_TYPE_NETFILTER, }; enum bpf_attach_type {
@@ -1050,6 +1051,7 @@ enum bpf_link_type {BPF_LINK_TYPE_PERF_EVENT =7 ,BPF_LINK_TYPE_KPROBE_MULTI =8 ,BPF_LINK_TYPE_STRUCT_OPS =9 , +BPF_LINK_TYPE_NETFILTER =10 , MAX_BPF_LINK_TYPE, };
@@ -1560,6 +1562,13 @@ union bpf_attr {*/ __u64 cookie; } tracing; +struct { +__u32 pf; +__u32 hooknum; +__s32 prio; +__u32 flags; +__u64 reserved[2 ]; + } netfilter; }; } link_create;
@@ -6410,6 +6419,12 @@ struct bpf_link_info {struct {__u32 map_id; } struct_ops; +struct { +__u32 pf; +__u32 hooknum; +__s32 priority; +__u32 flags; + } netfilter; }; } __attribute__((aligned(8)));
tools/lib/bpf/libbpf.c +2 -0
@@ -130,6 +130,7 @@ static const char * const link_type_name[] = { [BPF_LINK_TYPE_PERF_EVENT] = "perf_event", [BPF_LINK_TYPE_KPROBE_MULTI] = "kprobe_multi", [BPF_LINK_TYPE_STRUCT_OPS] = "struct_ops", + [BPF_LINK_TYPE_NETFILTER] = "netfilter", };static const char *const map_type_name[] = {
@@ -8641,6 +8642,7 @@ static const struct bpf_sec_def section_defs[] = {SEC_DEF ("struct_ops+" ,STRUCT_OPS ,0 ,SEC_NONE ),SEC_DEF ("struct_ops.s+" ,STRUCT_OPS ,0 ,SEC_SLEEPABLE ),SEC_DEF ("sk_lookup" ,SK_LOOKUP ,BPF_SK_LOOKUP ,SEC_ATTACHABLE ), + SEC_DEF("netfilter", NETFILTER, 0, SEC_NONE), };static size_t custom_sec_def_cnt;
Signature · 1 line
2.39.2
Re: [PATCH bpf-next v3 5/6] tools: bpftool: print netfilter link info
2023-04-18 15:10 UTC+0200 ~ Florian Westphal <[email protected]>
Quoted 89 lines
Dump protocol family, hook and priority value:
$ bpftool link 2: netfilter prog 14 ip input prio -128 pids install(3264) 5: netfilter prog 14 ip6 forward prio 21 pids a.out(3387) 9: netfilter prog 14 ip prerouting prio 123 pids a.out(5700) 10: netfilter prog 14 ip input prio 21 pids test2(5701)v2: Quentin Monnet suggested to also add 'bpftool net' support:
$ bpftool net xdp:tc:
flow_dissector:netfilter:
ip prerouting prio 21
prog_id14
ip input prio -128prog_id14
ip input prio 21prog_id14
ip forward prio 21prog_id14
ip output prio 21prog_id14
ip postrouting prio 21prog_id14'bpftool net' only dumps netfilter link type. netfilter links are sorted by protocol family, hook and priority.
Suggested-by Quentin Monnet <[email protected]>Signed-off-by Florian Westphal <[email protected]>--- tools/bpf/bpftool/link.c | 83 ++++++++++++++++++++++++++ tools/bpf/bpftool/main.h | 3 + tools/bpf/bpftool/net.c | 105 +++++++++++++++++++++++++++++++++ tools/include/uapi/linux/bpf.h | 15 +++++ tools/lib/bpf/libbpf.c | 2 + 5 files changed, 208 insertions(+)tools/bpf/bpftool/net.c +35
-0@@ -647,6 +647,107 @@ static int do_detach(int argc, char **argv) +static void show_link_netfilter (void ) +{ +unsigned int nf_link_len =0 , nf_link_count =0 ; +struct bpf_link_info *nf_link_info =NULL ; +__u32 id =0 ; + +while (true) { +struct bpf_link_info info; +int fd, err; +__u32 len; + + err =bpf_link_get_next_id (id, &id); +if (err) { +if (errno ==ENOENT ) +break ; +p_err ("can't get next link: %s (id %d)" ,strerror (errno), id); +break ; + } + + fd =bpf_link_get_fd_by_id (id); +if (fd <0 ) { +p_err ("can't get link by id (%u): %s" , id,strerror (errno)); +continue ; + } + +memset (&info,0 ,sizeof (info)); + len =sizeof (info); + + err =bpf_link_get_info_by_fd (fd, &info, &len); + +close (fd); + +if (err) { +p_err ("can't get link info for fd %d: %s" , fd,strerror (errno)); +continue ;
tools/bpf/bpftool/net.c static int do_detach(int argc, char **argv) · line 692
Quoted 10 lines
tools/bpf/bpftool/net.c +10
-0+ } + +if (info.type !=BPF_LINK_TYPE_NETFILTER ) +continue ; + +if (nf_link_count >= nf_link_len) { +struct bpf_link_info *expand; + +if (nf_link_count > (INT_MAX /sizeof (info))) { +fprintf (stderr,"link count %d\n" , nf_link_count);
The only nit I have is that we could use p_err() here, and have a more descriptive message (letting user know that we've reached a limit).
Looks all good otherwise. Thanks!
Florian Westphal
maintainerRe: [PATCH bpf-next v3 5/6] tools: bpftool: print netfilter link info
Quoted 5 lines · Quentin Monnet
tools/bpf/bpftool/net.c static int do_detach(int argc, char **argv) · line 716
Quoted 2 lines
tools/bpf/bpftool/net.c +2
-0+if (nf_link_count > (INT_MAX /sizeof (info))) { +fprintf (stderr,"link count %d\n" , nf_link_count);The only nit I have is that we could use
p_err()here, and have a more descriptive message (letting user know that we've reached a limit).
Drats, I'll replace this and will retain your RvB tag in v4, thanks.
Florian Westphal
maintainerPATCH v3 6/6 bpf: add test_run support for netfilter program type
In reply to Florian Westphalalso extend prog_tests with a small retval test: values other than accept or drop (0, 1) will cause issues.
NF_QUEUE could be implemented later if we can guarantee that attachment of such programs can be rejected if they get attached to a pf/hook that doesn't support async reinjection.
NF_STOLEN could be implemented via trusted helpers that can guarantee that the skb will eventually be free'd.
$ ./test_progs --allow=verifier_netfilter_retcode #278/1 verifier_netfilter_retcode/bpf_exit with invalid return code. test1:OK #278/2 verifier_netfilter_retcode/bpf_exit with valid return code. test2:OK #278/3 verifier_netfilter_retcode/bpf_exit with valid return code. test3:OK #278/4 verifier_netfilter_retcode/bpf_exit with invalid return code. test4:OK #278 verifier_netfilter_retcode:OK
--- include/linux/bpf.h | 3 + net/bpf/test_run.c | 140 ++++++++++++++++++ net/netfilter/nf_bpf_link.c | 1 + .../selftests/bpf/prog_tests/verifier.c | 2 + .../bpf/progs/verifier_netfilter_retcode.c | 49 ++++++ 5 files changed, 195 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/verifier_netfilter_retcode.c
include/linux/bpf.h +3 -0
@@ -2264,6 +2264,9 @@ int bpf_prog_test_run_raw_tp(struct bpf_prog *prog,int bpf_prog_test_run_sk_lookup (struct bpf_prog *prog,const union bpf_attr *kattr,union bpf_attr __user *uattr); +int bpf_prog_test_run_nf (struct bpf_prog *prog, +const union bpf_attr *kattr, +union bpf_attr __user *uattr);bool btf_ctx_access (int off,int size,enum bpf_access_type type,const struct bpf_prog *prog,struct bpf_insn_access_aux *info);
net/bpf/test_run.c +140 -0
153 lines not on this page · raw message
net/netfilter/nf_bpf_link.c +1 -0
@@ -167,6 +167,7 @@ int bpf_nf_link_attach(const union bpf_attr *attr, struct bpf_prog *prog) }const struct bpf_prog_ops netfilter_prog_ops = { + .test_run = bpf_prog_test_run_nf, };static bool nf_ptr_to_btf_id (struct bpf_insn_access_aux *info,const char *name)
tools/testing/selftests/bpf/prog_tests/verifier.c +2 -0
@@ -29,6 +29,7 @@#include "verifier_map_ret_val.skel.h" #include "verifier_masking.skel.h" #include "verifier_meta_access.skel.h" +#include "verifier_netfilter_retcode.skel.h" #include "verifier_raw_stack.skel.h" #include "verifier_raw_tp_writable.skel.h" #include "verifier_reg_equal.skel.h"
@@ -94,6 +95,7 @@ void test_verifier_map_ptr(void) { RUN(verifier_map_ptr); }void test_verifier_map_ret_val (void ) {RUN (verifier_map_ret_val); }void test_verifier_masking (void ) {RUN (verifier_masking); }void test_verifier_meta_access (void ) {RUN (verifier_meta_access); } +void test_verifier_netfilter_retcode (void ) {RUN (verifier_netfilter_retcode); }void test_verifier_raw_stack (void ) {RUN (verifier_raw_stack); }void test_verifier_raw_tp_writable (void ) {RUN (verifier_raw_tp_writable); }void test_verifier_reg_equal (void ) {RUN (verifier_reg_equal); }
tools/testing/selftests/bpf/progs/verifier_netfilter_retcode.c new file +49 -0
49 lines not on this page · raw message
Signature · 1 line
2.39.2