bpf: add netfilter program type
Subsystems (5)
Florian Westphal
maintainerv2 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' and assumes skb dynptrs are used rather than 'direct packet access'.
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;
}(output can be observed via /sys/kernel/tracing/trace_pipe).
At this point I think its fairly complete. Known problems are:
- no test cases, I will look into this. Might take some time though because I might have to extend libbpf first.
- nfnetlink_hook needs minor work so that it can dump the bpf program id. As-is, userspace could see that a bpf program is attached to e.g. forward and output, but it cannot tell which program. This is fairly simple and doesn't need changes on bpf side.
I will work on these address those two next unless anyone spots a fundamental issue with this rfc set.
Florian Westphal (3):
bpf: add bpf_link support for BPF_NETFILTER programs
libbpf: sync header file, add nf prog section name
bpf: minimal support for programs hooked into netfilter framework
include/linux/bpf_types.h | 4 + include/linux/netfilter.h | 1 + include/net/netfilter/nf_hook_bpf.h | 8 ++ include/uapi/linux/bpf.h | 12 ++ kernel/bpf/btf.c | 5 + kernel/bpf/syscall.c | 6 + kernel/bpf/verifier.c | 3 + net/netfilter/Kconfig | 3 + net/netfilter/Makefile | 1 + net/netfilter/nf_bpf_link.c | 192 ++++++++++++++++++++++++++++ tools/include/uapi/linux/bpf.h | 12 ++ tools/lib/bpf/libbpf.c | 1 + 12 files changed, 248 insertions(+) create mode 100644 include/net/netfilter/nf_hook_bpf.h create mode 100644 net/netfilter/nf_bpf_link.c
Signature · 1 line
2.39.2
Florian Westphal
maintainerRFC PATCH v2 1/3 bpf: add bpf_link support for BPF_NETFILTER programs
Add bpf_link support skeleton. To keep this reviewable, no bpf program can be invoked here, if a program would be attached only a c-stub is called.
This 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 = BPF_NETFILTER;
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'.
--- include/linux/netfilter.h | 1 + include/net/netfilter/nf_hook_bpf.h | 2 + include/uapi/linux/bpf.h | 12 +++ kernel/bpf/syscall.c | 6 ++ net/netfilter/Kconfig | 3 + net/netfilter/Makefile | 1 + net/netfilter/nf_bpf_link.c | 116 ++++++++++++++++++++++++++++ 7 files changed, 141 insertions(+) create mode 100644 include/net/netfilter/nf_hook_bpf.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_hook_bpf.h new file +2 -0
@@ -0,0 +1,2 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +int bpf_nf_link_attach (const union bpf_attr *attr,struct bpf_prog *prog);
include/uapi/linux/bpf.h +12 -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 {
@@ -1049,6 +1050,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, };
@@ -1543,6 +1545,11 @@ union bpf_attr {*/ __u64 cookie; } tracing; +struct { +__u32 pf; +__u32 hooknum; +__s32 prio; + } netfilter; }; } link_create;
@@ -6373,6 +6380,11 @@ struct bpf_link_info {struct {__u32 ifindex; } xdp; +struct { +__u32 pf; +__u32 hooknum; +__s32 priority; + } 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_hook_bpf.h> #define IS_FD_ARRAY (map) ((map)->map_type == BPF_MAP_TYPE_PERF_EVENT_ARRAY || \ (map)->map_type == BPF_MAP_TYPE_CGROUP_ARRAY || \
@@ -2448,6 +2449,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 */
@@ -4562,6 +4564,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 :
@@ -4628,6 +4631,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 +116 -0
116 lines not on this page · raw message
Signature · 1 line
2.39.2
kernel test robot
build botRe: [PATCH RFC v2 bpf-next 1/3] bpf: add bpf_link support for BPF_NETFILTER programs
reproduce (this is a W=1 build): # https://github.com/intel-lab-lkp/linux/commit/dafd9c7dce974be4bf60f89c8427a765acfcba77 git remote add linux-review https://github.com/intel-lab-lkp/linux git fetch…
Hi Florian,
[FYI, it's a private test report for your RFC patch.] [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/20230303-013022 base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master patch link: https://lore.kernel.org/r/20230302172757.9548-2-fw%40strlen.de patch subject: [PATCH RFC v2 bpf-next 1/3] bpf: add bpf_link support for BPF_NETFILTER programs config: i386-randconfig-a003 (https://download.01.org/0day-ci/archive/20230303/[email protected]/config) compiler: gcc-11 (Debian 11.3.0-8) 11.3.0
reproduce (this is a W=1 build):
# https://github.com/intel-lab-lkp/linux/commit/dafd9c7dce974be4bf60f89c8427a765acfcba77
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/20230303-013022 git checkout dafd9c7dce974be4bf60f89c8427a765acfcba77
# save the config file
mkdir build_dir && cp config build_dir/.config
make W=1 O=build_dir ARCH=i386 olddefconfig
make W=1 O=build_dir ARCH=i386 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 >>):
ld: kernel/bpf/syscall.o: in function `link_create':
>> kernel/bpf/syscall.c:4641: undefined reference to `bpf_nf_link_attach'
vim +4641 kernel/bpf/syscall.c
4551
4552 #define BPF_LINK_CREATE_LAST_FIELD link_create.kprobe_multi.cookies
4553 static int link_create(union bpf_attr *attr, bpfptr_t uattr)
4554 {
4555 enum bpf_prog_type ptype;
4556 struct bpf_prog *prog;
4557 int ret;
4558
4559 if (CHECK_ATTR(BPF_LINK_CREATE))
4560 return -EINVAL;
4561
4562 prog = bpf_prog_get(attr->link_create.prog_fd);
4563 if (IS_ERR(prog))
4564 return PTR_ERR(prog);
4565
4566 ret = bpf_prog_attach_check_attach_type(prog,
4567 attr->link_create.attach_type);
4568 if (ret)
4569 goto out;
4570
4571 switch (prog->type) {
4572 case BPF_PROG_TYPE_EXT:
4573 case BPF_PROG_TYPE_NETFILTER:
4574 break;
4575 case BPF_PROG_TYPE_PERF_EVENT:
4576 case BPF_PROG_TYPE_TRACEPOINT:
4577 if (attr->link_create.attach_type != BPF_PERF_EVENT) {
4578 ret = -EINVAL;
4579 goto out;
4580 }
4581 break;
4582 case BPF_PROG_TYPE_KPROBE:
4583 if (attr->link_create.attach_type != BPF_PERF_EVENT &&
4584 attr->link_create.attach_type != BPF_TRACE_KPROBE_MULTI) {
4585 ret = -EINVAL;
4586 goto out;
4587 }
4588 break;
4589 default:
4590 ptype = attach_type_to_prog_type(attr->link_create.attach_type);
4591 if (ptype == BPF_PROG_TYPE_UNSPEC || ptype != prog->type) {
4592 ret = -EINVAL;
4593 goto out;
4594 }
4595 break;
4596 }
4597
4598 switch (prog->type) {
4599 case BPF_PROG_TYPE_CGROUP_SKB:
4600 case BPF_PROG_TYPE_CGROUP_SOCK:
4601 case BPF_PROG_TYPE_CGROUP_SOCK_ADDR:
4602 case BPF_PROG_TYPE_SOCK_OPS:
4603 case BPF_PROG_TYPE_CGROUP_DEVICE:
4604 case BPF_PROG_TYPE_CGROUP_SYSCTL:
4605 case BPF_PROG_TYPE_CGROUP_SOCKOPT:
4606 ret = cgroup_bpf_link_attach(attr, prog);
4607 break;
4608 case BPF_PROG_TYPE_EXT:
4609 ret = bpf_tracing_prog_attach(prog,
4610 attr->link_create.target_fd,
4611 attr->link_create.target_btf_id,
4612 attr->link_create.tracing.cookie);
4613 break;
4614 case BPF_PROG_TYPE_LSM:
4615 case BPF_PROG_TYPE_TRACING:
4616 if (attr->link_create.attach_type != prog->expected_attach_type) {
4617 ret = -EINVAL;
4618 goto out;
4619 }
4620 if (prog->expected_attach_type == BPF_TRACE_RAW_TP)
4621 ret = bpf_raw_tp_link_attach(prog, NULL);
4622 else if (prog->expected_attach_type == BPF_TRACE_ITER)
4623 ret = bpf_iter_link_attach(attr, uattr, prog);
4624 else if (prog->expected_attach_type == BPF_LSM_CGROUP)
4625 ret = cgroup_bpf_link_attach(attr, prog);
4626 else
4627 ret = bpf_tracing_prog_attach(prog,
4628 attr->link_create.target_fd,
4629 attr->link_create.target_btf_id,
4630 attr->link_create.tracing.cookie);
4631 break;
4632 case BPF_PROG_TYPE_FLOW_DISSECTOR:
4633 case BPF_PROG_TYPE_SK_LOOKUP:
4634 ret = netns_bpf_link_create(attr, prog);
4635 break;
4636 #ifdef CONFIG_NET
4637 case BPF_PROG_TYPE_XDP:
4638 ret = bpf_xdp_link_attach(attr, prog);
4639 break;
4640 case BPF_PROG_TYPE_NETFILTER:
> 4641 ret = bpf_nf_link_attach(attr, prog); 4642 break;
4643 #endif
4644 case BPF_PROG_TYPE_PERF_EVENT:
4645 case BPF_PROG_TYPE_TRACEPOINT:
4646 ret = bpf_perf_link_attach(attr, prog);
4647 break;
4648 case BPF_PROG_TYPE_KPROBE:
4649 if (attr->link_create.attach_type == BPF_PERF_EVENT)
4650 ret = bpf_perf_link_attach(attr, prog);
4651 else
4652 ret = bpf_kprobe_multi_link_attach(attr, prog);
4653 break;
4654 default:
4655 ret = -EINVAL;
4656 }
4657
4658 out:
4659 if (ret < 0)
4660 bpf_prog_put(prog);
4661 return ret;
4662 }
4663
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests
Re: [PATCH RFC v2 bpf-next 1/3] bpf: add bpf_link support for BPF_NETFILTER programs
In reply to Florian WestphalQuoted 84 lines · Florian Westphal
Add
bpf_linksupport skeleton. To keep this reviewable, no bpf program can be invoked here, if a program would be attached only a c-stub is called.This 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 = BPF_NETFILTER; 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_NETFILTERprogram invocation is added in followup change.
NF_HOOK_OP_BPFenum will eventually be read fromnfnetlink_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'.Signed-off-by Florian Westphal <[email protected]>--- include/linux/netfilter.h | 1 + include/net/netfilter/nf_hook_bpf.h | 2 + include/uapi/linux/bpf.h | 12 +++ kernel/bpf/syscall.c | 6 ++ net/netfilter/Kconfig | 3 + net/netfilter/Makefile | 1 + net/netfilter/nf_bpf_link.c | 116 ++++++++++++++++++++++++++++ 7 files changed, 141 insertions(+)create mode 100644
include/net/netfilter/nf_hook_bpf.hcreate mode 100644net/netfilter/nf_bpf_link.cinclude/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_hook_bpf.h new file +2
-0@@ -0,0 +1,2 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +int bpf_nf_link_attach(const union bpf_attr *attr, struct bpf_prog*prog);
include/uapi/linux/bpf.h +2
-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 {@@ -1049,6 +1050,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, };
include/uapi/linux/bpf.h union bpf_attr { · line 1552
Quoted 8 lines
include/uapi/linux/bpf.h +5
-0@@ -1543,6 +1545,11 @@ union bpf_attr {*/ __u64 cookie; } tracing; +struct { +__u32 pf; +__u32 hooknum; +__s32 prio; + } netfilter;
For recent tc BPF program extensions, we've discussed that it might be better to have an option to attach program before/after another one in the chain. So the API essentially would receive a before/after flag + fd/id of the program where we want to be.
Should we do something similar here? See [0] for the original discussion.
Quoted 215 lines
include/uapi/linux/bpf.h +5
-0}; } link_create;@@ -6373,6 +6380,11 @@ struct bpf_link_info {struct {__u32 ifindex; } xdp; +struct { +__u32 pf; +__u32 hooknum; +__s32 priority; + } netfilter; }; } __attribute__((aligned(8)));kernel/bpf/syscall.c +1
-0@@ -35,6 +35,7 @@#include <linux/rcupdate_trace.h> #include <linux/memcontrol.h> #include <linux/trace_events.h> +#include <net/netfilter/nf_hook_bpf.h> #define IS_FD_ARRAY (map) ((map)->map_type == BPF_MAP_TYPE_PERF_EVENT_ARRAY || \(map)->map_type == BPF_MAP_TYPE_CGROUP_ARRAY || \kernel/bpf/syscall.c +1
-0@@ -2448,6 +2449,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 */
kernel/bpf/syscall.c +1
-0@@ -4562,6 +4564,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:kernel/bpf/syscall.c +3
-0@@ -4628,6 +4631,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_ADVANCEDnet/netfilter/Makefile +0
-0@@ -22,6 +22,7 @@ nf_conntrack-$(CONFIG_DEBUG_INFO_BTF) +=nf_conntrack_bpf.o
endifobj-$(CONFIG_NETFILTER) = netfilter.onet/netfilter/Makefile +1
-0+obj-$(CONFIG_NETFILTER_BPF_LINK) += nf_bpf_link.o obj-$(CONFIG_NETFILTER_NETLINK) += nfnetlink.o obj-$(CONFIG_NETFILTER_NETLINK_ACCT) += nfnetlink_acct.onet/netfilter/nf_bpf_link.c new file +7
-0@@ -0,0 +1,116 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <linux/bpf.h> +#include <linux/netfilter.h> + +#include <net/netfilter/nf_hook_bpf.h> + +static unsigned int nf_hook_run_bpf(void *bpf_prog, struct sk_buff *skb,const struct
nf_hook_state*s)net/netfilter/nf_bpf_link.c new file +13
-0+{ +return NF_ACCEPT ; +} + +struct bpf_nf_link { +struct bpf_link link; +struct nf_hook_ops hook_ops; +struct net *net; +}; + +static void bpf_nf_link_release (struct bpf_link *link) +{ + struct bpf_nf_link *nf_link = container_of(link, struct bpf_nf_link,link);
net/netfilter/nf_bpf_link.c new file +7
-0+ +nf_unregister_net_hook (nf_link->net, &nf_link->hook_ops); +} + +static void bpf_nf_link_dealloc (struct bpf_link *link) +{ + struct bpf_nf_link *nf_link = container_of(link, struct bpf_nf_link,link);
net/netfilter/nf_bpf_link.c new file +14
-0+ +kfree (nf_link); +} + +static int bpf_nf_link_detach (struct bpf_link *link) +{ +bpf_nf_link_release (link); +return 0 ; +} + +static void bpf_nf_link_show_info (const struct bpf_link *link, +struct seq_file *seq) +{ + struct bpf_nf_link *nf_link = container_of(link, struct bpf_nf_link,link);
net/netfilter/nf_bpf_link.c new file +10
-0+ +seq_printf (seq,"pf:\t%u\thooknum:\t%u\tprio:\t%d\n" , + nf_link->hook_ops.pf, nf_link->hook_ops.hooknum, + nf_link->hook_ops.priority); +} + +static int bpf_nf_link_fill_link_info (const struct bpf_link *link, +struct bpf_link_info *info) +{ + struct bpf_nf_link *nf_link = container_of(link, struct bpf_nf_link,link);
net/netfilter/nf_bpf_link.c new file +9
-0+ + info->netfilter.pf = nf_link->hook_ops.pf; + info->netfilter.hooknum = nf_link->hook_ops.hooknum; + info->netfilter.priority = nf_link->hook_ops.priority; + +return 0 ; +} + +static int bpf_nf_link_update(struct bpf_link *link, struct bpf_prog
*new_prog,net/netfilter/nf_bpf_link.c new file +29
-0+ struct bpf_prog *old_prog) +{ +return -EOPNOTSUPP ; +} + +static const struct bpf_link_ops bpf_nf_link_lops = { + .release = bpf_nf_link_release, + .dealloc = bpf_nf_link_dealloc, + .detach = bpf_nf_link_detach, + .show_fdinfo = bpf_nf_link_show_info, + .fill_link_info = bpf_nf_link_fill_link_info, + .update_prog = bpf_nf_link_update, +}; + +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 ; + + link =kzalloc (sizeof (*link),GFP_USER ); +if (!link) +return -ENOMEM ; + + bpf_link_init(&link->link, BPF_LINK_TYPE_NETFILTER, &bpf_nf_link_lops,prog);
net/netfilter/nf_bpf_link.c new file +27
-1+ + link->hook_ops.hook = nf_hook_run_bpf; + link->hook_ops.hook_ops_type =NF_HOOK_OP_BPF ; + link->hook_ops.priv = prog; + + link->hook_ops.pf = attr->link_create.netfilter.pf; + link->hook_ops.priority = attr->link_create.netfilter.prio; + link->hook_ops.hooknum = attr->link_create.netfilter.hooknum; + + link->net = net; + + err =bpf_link_prime (&link->link, &link_primer); +if (err) + goto out_free; + + err =nf_register_net_hook (net, &link->hook_ops); +if (err) { +bpf_link_cleanup (&link_primer); + goto out_free; + } + +return bpf_link_settle (&link_primer); + +out_free: +kfree (link); +return err; +} --2.39.2
Florian Westphal
maintainerRe: [PATCH RFC v2 bpf-next 1/3] bpf: add bpf_link support for BPF_NETFILTER programs
Quoted 12 lines · Stanislav Fomichev
include/uapi/linux/bpf.h union bpf_attr { · line 1552
Quoted 5 lines · Florian Westphal
include/uapi/linux/bpf.h +5
-0+struct { +__u32 pf; +__u32 hooknum; +__s32 prio; + } netfilter;For recent tc BPF program extensions, we've discussed that it might be better
to have an option to attach program before/after another one in the chain. So the API essentially would receive a before/after flag + fd/id of the
Quoted 4 lines
Should we do something similar here? See [0] for the original discussion.
Thanks for the pointer, I will have a look.
The above exposes the "prio" of netfilter hooks, so someone that needs their hook to run early on, say, before netfilters nat engine, could just use INT_MIN.
We could -- for nf bpf -- make the bpf_link fail if a hook with the same priority already exists to avoid the "undefined behaviour" here (same prio means register order decides what hook function runs first ...).
This could be relevant if you have e.g. one bpf program collecting statistics vs. one doing drops.
I'll dig though the thread and would try to mimic the tc link mechanism as close as possible.
Re: [PATCH RFC v2 bpf-next 1/3] bpf: add bpf_link support for BPF_NETFILTER programs
Hi Florian, Stan,
Quoted 29 lines · Florian Westphal
Quoted 12 lines · Stanislav Fomichev
include/uapi/linux/bpf.h union bpf_attr { · line 1552
Quoted 5 lines · Florian Westphal
include/uapi/linux/bpf.h +5
-0+struct { +__u32 pf; +__u32 hooknum; +__s32 prio; + } netfilter;For recent tc BPF program extensions, we've discussed that it might be better
to have an option to attach program before/after another one in the chain. So the API essentially would receive a before/after flag + fd/id of theQuoted 4 lines
Should we do something similar here? See [0] for the original discussion.
Thanks for the pointer, I will have a look.
The above exposes the "prio" of netfilter hooks, so someone that needs their hook to run early on, say, before netfilters nat engine, could just use
INT_MIN.We could -- for nf bpf -- make the
bpf_linkfail if a hook with the same priority already exists to avoid the "undefined behaviour" here (same prio means register order decides what hook function runs first ...).
Quoted 5 lines
This could be relevant if you have e.g. one bpf program collecting statistics vs. one doing drops.
I'll dig though the thread and would try to mimic the tc link mechanism as close as possible.
While I think the direction the TC link discussion took is totally fine, TC has the advantage (IIUC) of being a somewhat isolated hook. Meaning it does not make sense for a user to mix priority values && before/after semantics.
Netfilter is different in that there is by default modules active with fixed priority values. So mixing in before/after semantics here could get confusing.
Thanks,
Daniel
Re: [PATCH RFC v2 bpf-next 1/3] bpf: add bpf_link support for BPF_NETFILTER programs
Quoted 39 lines · Daniel Xu
Hi Florian, Stan,
Quoted 29 lines · Florian Westphal
Quoted 12 lines · Stanislav Fomichev
include/uapi/linux/bpf.h union bpf_attr { · line 1552
Quoted 5 lines · Florian Westphal
include/uapi/linux/bpf.h +5
-0+struct { +__u32 pf; +__u32 hooknum; +__s32 prio; + } netfilter;For recent tc BPF program extensions, we've discussed that it might be better
to have an option to attach program before/after another one in the chain. So the API essentially would receive a before/after flag + fd/id of theQuoted 4 lines
Should we do something similar here? See [0] for the original discussion.
Thanks for the pointer, I will have a look.
The above exposes the "prio" of netfilter hooks, so someone that needs their hook to run early on, say, before netfilters nat engine, could just use
INT_MIN.We could -- for nf bpf -- make the
bpf_linkfail if a hook with the same priority already exists to avoid the "undefined behaviour" here (same prio means register order decides what hook function runs first ...).Quoted 5 lines
This could be relevant if you have e.g. one bpf program collecting statistics vs. one doing drops.
I'll dig though the thread and would try to mimic the tc link mechanism as close as possible.
Quoted 8 lines
While I think the direction the TC link discussion took is totally fine, TC has the advantage (IIUC) of being a somewhat isolated hook. Meaning it does not make sense for a user to mix priority values && before/after semantics.
Netfilter is different in that there is by default modules active with fixed priority values. So mixing in before/after semantics here could get confusing.
I don't remember the details, so pls correct me, but last time I looked, this priority was basically an ordering within a hook? And there were a bunch of kernel-hardcoded values. So either that whole story has to become a UAPI (so the bpf program knows before/after which kernel hook it has to run), or we need some other ordering mechanism. (I'm not sure what's the story with bpf vs kernel hooks interop, so maybe it's all moot?)
Am I missing something? Can you share more about why those fixed priorities are fine?
Quoted 2 lines
Thanks,
Daniel
Re: [PATCH RFC v2 bpf-next 1/3] bpf: add bpf_link support for BPF_NETFILTER programs
Hi Stan,
Quoted 45 lines · Stanislav Fomichev
Quoted 44 lines · Daniel Xu
Hi Florian, Stan,
Quoted 29 lines · Florian Westphal
Quoted 12 lines · Stanislav Fomichev
include/uapi/linux/bpf.h union bpf_attr { · line 1552
Quoted 5 lines · Florian Westphal
include/uapi/linux/bpf.h +5
-0+struct { +__u32 pf; +__u32 hooknum; +__s32 prio; + } netfilter;For recent tc BPF program extensions, we've discussed that it might be better
to have an option to attach program before/after another one in the chain. So the API essentially would receive a before/after flag + fd/id of theQuoted 4 lines
Should we do something similar here? See [0] for the original discussion.
Thanks for the pointer, I will have a look.
The above exposes the "prio" of netfilter hooks, so someone that needs their hook to run early on, say, before netfilters nat engine, could just use
INT_MIN.We could -- for nf bpf -- make the
bpf_linkfail if a hook with the same priority already exists to avoid the "undefined behaviour" here (same prio means register order decides what hook function runs first ...).Quoted 5 lines
This could be relevant if you have e.g. one bpf program collecting statistics vs. one doing drops.
I'll dig though the thread and would try to mimic the tc link mechanism as close as possible.
While I think the direction the TC link discussion took is totally fine, TC has the advantage (IIUC) of being a somewhat isolated hook. Meaning it does not make sense for a user to mix priority values && before/after semantics.
Quoted 6 lines
Quoted 3 lines
Netfilter is different in that there is by default modules active with fixed priority values. So mixing in before/after semantics here could get confusing.
I don't remember the details, so pls correct me, but last time I looked, this priority was basically an ordering within a hook?
Yeah, that is my understanding as well.
Quoted 4 lines
And there were a bunch of kernel-hardcoded values. So either that whole story has to become a UAPI (so the bpf program knows before/after which kernel hook it has to run), or we need some other ordering mechanism.
I'm not sure what you mean by "whole story" but netfilter kernel modules register via a priority value as well. As well as the modules the kernel ships. So there's that to consider.
(I'm not sure what's the story with bpf vs kernel
Quoted 3 lines
hooks interop, so maybe it's all moot?)
Am I missing something? Can you share more about why those fixed priorities are fine?
I guess I wouldn't say it's ideal (for all the reasons brought up in the previous discussion), but trying to use before/after semantics here would necessarily pull in a netfilter rework too, no? Or maybe there's some clever way to merge the two worlds and get both subsystems what they want.
Thanks,
Daniel
Re: [PATCH RFC v2 bpf-next 1/3] bpf: add bpf_link support for BPF_NETFILTER programs
Quoted 58 lines · Daniel Xu
Hi Stan,
Quoted 45 lines · Stanislav Fomichev
Quoted 44 lines · Daniel Xu
Hi Florian, Stan,
Quoted 29 lines · Florian Westphal
Quoted 12 lines · Stanislav Fomichev
include/uapi/linux/bpf.h union bpf_attr { · line 1552
Quoted 5 lines · Florian Westphal
include/uapi/linux/bpf.h +5
-0+struct { +__u32 pf; +__u32 hooknum; +__s32 prio; + } netfilter;For recent tc BPF program extensions, we've discussed that it might be better
to have an option to attach program before/after another one in the chain. So the API essentially would receive a before/after flag + fd/id of theQuoted 4 lines
Should we do something similar here? See [0] for the original discussion.
Thanks for the pointer, I will have a look.
The above exposes the "prio" of netfilter hooks, so someone that needs their hook to run early on, say, before netfilters nat engine, could just use
INT_MIN.We could -- for nf bpf -- make the
bpf_linkfail if a hook with the same priority already exists to avoid the "undefined behaviour" here (same prio means register order decides what hook function runs first ...).Quoted 5 lines
This could be relevant if you have e.g. one bpf program collecting statistics vs. one doing drops.
I'll dig though the thread and would try to mimic the tc link mechanism as close as possible.
While I think the direction the TC link discussion took is totally fine, TC has the advantage (IIUC) of being a somewhat isolated hook. Meaning it does not make sense for a user to mix priority values && before/after semantics.
Quoted 6 lines
Quoted 3 lines
Netfilter is different in that there is by default modules active with fixed priority values. So mixing in before/after semantics here could get confusing.
I don't remember the details, so pls correct me, but last time I looked, this priority was basically an ordering within a hook?
Yeah, that is my understanding as well.
Quoted 8 lines
Quoted 4 lines
And there were a bunch of kernel-hardcoded values. So either that whole story has to become a UAPI (so the bpf program knows before/after which kernel hook it has to run), or we need some other ordering mechanism.
I'm not sure what you mean by "whole story" but netfilter kernel modules register via a priority value as well. As well as the modules the kernel ships. So there's that to consider.
Sorry for not being clear. What I meant here is that we'd have to export those existing priorities in the UAPI headers and keep those numbers stable. Otherwise it seems impossible to have a proper interop between those fixed existing priorities and new bpf modules? (idk if that's a real problem or I'm overthinking)
Because the problem as I see it is as follows:
Let's say I want to trigger before/after kernel module X. I need to know its priority and it has to be stable. Alternatively, there should be some way to query the priority of module X so I can do +1/-1 (which is essentially "before X/after X" semantics).
Quoted 10 lines
(I'm not sure what's the story with bpf vs kernel
Quoted 3 lines
hooks interop, so maybe it's all moot?)
Am I missing something? Can you share more about why those fixed priorities are fine?I guess I wouldn't say it's ideal (for all the reasons brought up in the previous discussion), but trying to use before/after semantics here would necessarily pull in a netfilter rework too, no? Or maybe there's some clever way to merge the two worlds and get both subsystems what they want.
Right, I don't have an answer here, just trying to understand whether (as a side effect of those patches) we're really making those existing priorities a UAPI or not :-)
Quoted 2 lines
Thanks,
Daniel
Florian Westphal
maintainerRe: [PATCH RFC v2 bpf-next 1/3] bpf: add bpf_link support for BPF_NETFILTER programs
Quoted 9 lines · Stanislav Fomichev
Quoted 3 lines
I'm not sure what you mean by "whole story" but netfilter kernel modules register via a priority value as well. As well as the modules the kernel ships. So there's that to consider.
Sorry for not being clear. What I meant here is that we'd have to export those existing priorities in the UAPI headers and keep those numbers stable. Otherwise it seems impossible to have a proper interop between those fixed existing priorities and new bpf modules? (idk if that's a real problem or I'm overthinking)
They are already in uapi and exported.
Re: [PATCH RFC v2 bpf-next 1/3] bpf: add bpf_link support for BPF_NETFILTER programs
Quoted 6 lines · Florian Westphal
Quoted 4 lines · Stanislav Fomichev
Quoted 3 lines
I'm not sure what you mean by "whole story" but netfilter kernel modules register via a priority value as well. As well as the modules the kernel ships. So there's that to consider.
Quoted 7 lines
Quoted 5 lines
Sorry for not being clear. What I meant here is that we'd have to export those existing priorities in the UAPI headers and keep those numbers stable. Otherwise it seems impossible to have a proper interop between those fixed existing priorities and new bpf modules? (idk if that's a real problem or I'm overthinking)
They are already in uapi and exported.
Oh, nice, then probably keeping those prios is the way to go. Up to you on whether to explore the alternative (before/after) or not. Agree with Daniel that it probably requires reworking netfilter internals and it's not really justified here.
kernel test robot
build botRe: [PATCH RFC v2 bpf-next 1/3] bpf: add bpf_link support for BPF_NETFILTER programs
In reply to Florian Westphalreproduce (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 #…
Hi Florian,
[FYI, it's a private test report for your RFC patch.] [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/20230303-013022 base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master patch link: https://lore.kernel.org/r/20230302172757.9548-2-fw%40strlen.de patch subject: [PATCH RFC v2 bpf-next 1/3] bpf: add bpf_link support for BPF_NETFILTER programs config: i386-randconfig-a002 (https://download.01.org/0day-ci/archive/20230303/[email protected]/config) compiler: clang version 14.0.6 (https://github.com/llvm/llvm-project f28c006a5895fc0e329fe15fead81e37457cb1d1)
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/dafd9c7dce974be4bf60f89c8427a765acfcba77
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/20230303-013022 git checkout dafd9c7dce974be4bf60f89c8427a765acfcba77
# save the config file
mkdir build_dir && cp config build_dir/.config
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=i386 olddefconfig COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 O=build_dir ARCH=i386 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 >>):
>> ld.lld: error: undefined symbol: bpf_nf_link_attach >>> referenced by syscall.c:4641 (kernel/bpf/syscall.c:4641) >>> kernel/bpf/syscall.o:(link_create) in archive vmlinux.a
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests
Florian Westphal
maintainerRFC PATCH v2 2/3 libbpf: sync header file, add nf prog section name
In reply to Florian Westphal--- tools/include/uapi/linux/bpf.h | 12 ++++++++++++ tools/lib/bpf/libbpf.c | 1 + 2 files changed, 13 insertions(+)
tools/include/uapi/linux/bpf.h +12 -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 {
@@ -1049,6 +1050,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, };
@@ -1543,6 +1545,11 @@ union bpf_attr {*/ __u64 cookie; } tracing; +struct { +__u32 pf; +__u32 hooknum; +__s32 prio; + } netfilter; }; } link_create;
@@ -6373,6 +6380,11 @@ struct bpf_link_info {struct {__u32 ifindex; } xdp; +struct { +__u32 pf; +__u32 hooknum; +__s32 priority; + } netfilter; }; } __attribute__((aligned(8)));
tools/lib/bpf/libbpf.c +1 -0
@@ -8570,6 +8570,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
Florian Westphal
maintainerRFC PATCH v2 3/3 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_hook_bpf.h | 6 +++ kernel/bpf/btf.c | 5 ++ kernel/bpf/verifier.c | 3 ++ net/netfilter/nf_bpf_link.c | 78 ++++++++++++++++++++++++++++- 5 files changed, 95 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_hook_bpf.h +6 -0
@@ -1,2 +1,8 @@/* SPDX-License-Identifier: GPL-2.0 */ + +struct bpf_nf_ctx { +const struct nf_hook_state *state; +struct sk_buff *skb; +}; +int bpf_nf_link_attach (const union bpf_attr *attr,struct bpf_prog *prog);
kernel/bpf/btf.c +5 -0
@@ -25,6 +25,9 @@#include <linux/bsearch.h> #include <linux/kobject.h> #include <linux/sysfs.h> + +#include <net/netfilter/nf_hook_bpf.h> +#include <net/sock.h> #include "../tools/lib/bpf/relo_core.h"
@@ -7726,6 +7729,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_SOCKET_FILTER ;default :return BTF_KFUNC_HOOK_MAX ; }
kernel/bpf/verifier.c +3 -0
@@ -13142,6 +13142,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/netfilter/nf_bpf_link.c +77 -1
92 lines not on this page · raw message
Signature · 1 line
2.39.2
Re: [PATCH RFC v2 bpf-next 3/3] bpf: minimal support for programs hooked into netfilter framework
Quoted 63 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_hook_bpf.h | 6 +++ kernel/bpf/btf.c | 5 ++ kernel/bpf/verifier.c | 3 ++ net/netfilter/nf_bpf_link.c | 78 ++++++++++++++++++++++++++++- 5 files changed, 95 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_hook_bpf.h +6
-0@@ -1,2 +1,8 @@/* SPDX-License-Identifier: GPL-2.0 */ + +struct bpf_nf_ctx { +const struct nf_hook_state *state; +struct sk_buff *skb; +}; +int bpf_nf_link_attach (const union bpf_attr *attr,struct bpf_prog *prog);kernel/bpf/btf.c +3
-0@@ -25,6 +25,9 @@#include <linux/bsearch.h> #include <linux/kobject.h> #include <linux/sysfs.h> + +#include <net/netfilter/nf_hook_bpf.h> +#include <net/sock.h> #include "../tools/lib/bpf/relo_core.h"
kernel/bpf/btf.c static int bpf_prog_type_to_kfunc_hook(enum bpf_prog_type prog_type) · line 7733
Quoted 5 lines
kernel/bpf/btf.c +2
-0@@ -7726,6 +7729,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_SOCKET_FILTER ;
The dynptr patch reuses the actual set between the different IDs, so this should probably define a new BTF_KFUNC_HOOK_NETFILTER, with an associated register_btf_kfunc_id_set() call?
-Toke
Florian Westphal
maintainerRe: [PATCH RFC v2 bpf-next 3/3] bpf: minimal support for programs hooked into netfilter framework
Quoted 7 lines · Toke Høiland-Jørgensen
kernel/bpf/btf.c static int bpf_prog_type_to_kfunc_hook(enum bpf_prog_type prog_type) · line 7733
Quoted 2 lines · Florian Westphal
kernel/bpf/btf.c +2
-0+case BPF_PROG_TYPE_NETFILTER : +return BTF_KFUNC_HOOK_SOCKET_FILTER ;The dynptr patch reuses the actual set between the different IDs, so this should probably define a new
BTF_KFUNC_HOOK_NETFILTER, with an associatedregister_btf_kfunc_id_set()call?
Good point, the above was a kludge that I forgot about.
I will wait for dynptr patchset to land and will add new BTF_KFUNC_HOOK_NETFILTER for next revision.
Re: [PATCH RFC v2 bpf-next 3/3] bpf: minimal support for programs hooked into netfilter framework
Quoted 9 lines · Florian Westphal
Quoted 7 lines · Toke Høiland-Jørgensen
kernel/bpf/btf.c static int bpf_prog_type_to_kfunc_hook(enum bpf_prog_type prog_type) · line 7733
Quoted 2 lines · Florian Westphal
kernel/bpf/btf.c +2
-0+case BPF_PROG_TYPE_NETFILTER : +return BTF_KFUNC_HOOK_SOCKET_FILTER ;The dynptr patch reuses the actual set between the different IDs, so this should probably define a new
BTF_KFUNC_HOOK_NETFILTER, with an associatedregister_btf_kfunc_id_set()call?
Quoted 4 lines
Good point, the above was a kludge that I forgot about.
I will wait for dynptr patchset to land and will add new
BTF_KFUNC_HOOK_NETFILTERfor next revision.
Sounds good! The dynptr series did land:
https://lore.kernel.org/r/167769421944.16358.12443693977215512909.git-patchwork-notify@kernel.org
-Toke
Quoted 53 lines · Florian Westphal
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' and assumes skb dynptrs are used rather than 'direct packet access'.
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,__u64flags,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")
intnf_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; }(output can be observed via
/sys/kernel/tracing/trace_pipe).At this point I think its fairly complete. Known problems are:
- no test cases, I will look into this. Might take some time though because I might have to extend libbpf first.
-nfnetlink_hookneeds minor work so that it can dump the bpf program id. As-is, userspace could see that a bpf program is attached to e.g. forward and output, but it cannot tell which program. This is fairly simple and doesn't need changes on bpf side.
Quoted 2 lines
I will work on these address those two next unless anyone spots a fundamental issue with this rfc set.
I only spotted one small nit on the third patch, which I replied to separately. Otherwise I think it looks pretty good, in fact I'm amazed at how little code it takes to enable this; nice work! :)
-Toke
Hi Florian,
Quoted 8 lines · Florian Westphal
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' and assumes skb dynptrs are used rather than 'direct packet access'.
[...]
Hope all is well. Do you have any updates on this series? I'm keen to start building on top of this work.
Thanks,
Daniel
Florian Westphal
maintainerQuoted 7 lines · Daniel Xu
Quoted 6 lines · Florian Westphal
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.
Quoted 7 lines
Quoted 2 lines
The new program type is 'tracing style' and assumes skb dynptrs are used rather than 'direct packet access'.
[...]
Hope all is well. Do you have any updates on this series? I'm keen to start building on top of this work.
Sorry, I was busy with other work so this got sidelined.
I've pushed what I hav atm to
https://git.breakpoint.cc/cgit/fw/bpf-next.git/log/?h=nf_bpf_hooks_07
I had no time so far to do the testing needed for a new official submission (e.g. bpf_link_info).
Compared to last uapi this now has a "flags" member that could be used to indicate "need defrag" and so on.
I hope I can submit this again early April.