Annotate kfuncs in .BTF_ids section
Subsystems (18)
v3 cover Annotate kfuncs in .BTF_ids section
=== Description ===
This is a bpf-treewide change that annotates all kfuncs as such inside .BTF_ids. This annotation eventually allows us to automatically generate kfunc prototypes from bpftool.
We store this metadata inside a yet-unused flags field inside struct btf_id_set8 (thanks Kumar!). pahole will be taught where to look.
More details about the full chain of events are available in commit 3's description.
The accompanying pahole changes (still needs some cleanup) can be viewed here on this "frozen" branch [0].
[0]: https://github.com/danobi/pahole/tree/kfunc_btf-mailed
=== Changelog ===
Changes from v2:
* Only WARN() for vmlinux kfuncs
Changes from v1:
* Move WARN_ON() up a call level
* Also return error when kfunc set is not properly tagged
* Use BTF_KFUNCS_START/END instead of flags
* Rename BTF_SET8_KFUNC to BTF_SET8_KFUNCS
Daniel Xu (3):
bpf: btf: Support flags for BTF_SET8 sets
bpf: btf: Add BTF_KFUNCS_START/END macro pair
bpf: treewide: Annotate BPF kfuncs in BTF
drivers/hid/bpf/hid_bpf_dispatch.c | 8 +++---- fs/verity/measure.c | 4 ++-- include/linux/btf_ids.h | 21 +++++++++++++++---- kernel/bpf/btf.c | 8 +++++++ kernel/bpf/cpumask.c | 4 ++-- kernel/bpf/helpers.c | 8 +++---- kernel/bpf/map_iter.c | 4 ++-- kernel/cgroup/rstat.c | 4 ++-- kernel/trace/bpf_trace.c | 8 +++---- net/bpf/test_run.c | 8 +++---- net/core/filter.c | 16 +++++++------- net/core/xdp.c | 4 ++-- net/ipv4/bpf_tcp_ca.c | 4 ++-- net/ipv4/fou_bpf.c | 4 ++-- net/ipv4/tcp_bbr.c | 4 ++-- net/ipv4/tcp_cubic.c | 4 ++-- net/ipv4/tcp_dctcp.c | 4 ++-- net/netfilter/nf_conntrack_bpf.c | 4 ++-- net/netfilter/nf_nat_bpf.c | 4 ++-- net/xfrm/xfrm_interface_bpf.c | 4 ++-- net/xfrm/xfrm_state_bpf.c | 4 ++-- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 8 +++---- 22 files changed, 81 insertions(+), 60 deletions(-)
Signature · 1 line
2.42.1
PATCH v3 1/3 bpf: btf: Support flags for BTF_SET8 sets
This commit adds support for flags on BTF_SET8s. struct btf_id_set8 already supported 32 bits worth of flags, but was only used for alignment purposes before.
We now use these bits to encode flags. The first use case is tagging kfunc sets with a flag so that pahole can recognize which BTF_ID_FLAGS(func, ..) are actual kfuncs.
--- include/linux/btf_ids.h | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)
include/linux/btf_ids.h +6 -4
@@ -21,6 +21,7 @@ struct btf_id_set8 {#include <linux/compiler.h> /* for __PASTE */ #include <linux/compiler_attributes.h> /* for __maybe_unused */ +#include <linux/stringify.h> /* * Following macros help to define lists of BTF IDs placed
@@ -183,17 +184,18 @@ extern struct btf_id_set name;* .word (1 << 3) | (1 << 1) | (1 << 2) * */ -#define __BTF_SET8_START (name, scope) \ +#define __BTF_SET8_START (name, scope, flags) \ +__BTF_ID_LIST(name, local) \ asm( \ ".pushsection " BTF_IDS_SECTION ",\"a\"; \n" \ "." #scope " __BTF_ID__set8__" #name "; \n" \ "__BTF_ID__set8__" #name ":; \n" \ -".zero 8 \n" \ +".zero 4 \n" \ +".long " __stringify(flags) "\n" \ ".popsection; \n");#define BTF_SET8_START (name) \ -__BTF_ID_LIST(name, local) \ -__BTF_SET8_START(name, local) +__BTF_SET8_START(name, local, 0)#define BTF_SET8_END (name) \ asm( \
Signature · 1 line
2.42.1
PATCH v3 2/3 bpf: btf: Add BTF_KFUNCS_START/END macro pair
In reply to Daniel XuThis macro pair is functionally equivalent to BTF_SET8_START/END, except with BTF_SET8_KFUNCS flag set in the btf_id_set8 flags field. The next commit will codemod all kfunc set8s to this new variant such that all kfuncs are tagged as such in .BTF_ids section.
--- include/linux/btf_ids.h | 11 +++++++++++ 1 file changed, 11 insertions(+)
include/linux/btf_ids.h +11 -0
@@ -8,6 +8,9 @@ struct btf_id_set {u32 ids[]; }; +/* This flag implies BTF_SET8 holds kfunc(s) */ +#define BTF_SET8_KFUNCS (1 << 0) +struct btf_id_set8 {u32 cnt;u32 flags;
@@ -204,6 +207,12 @@ asm( \ ".popsection; \n"); \extern struct btf_id_set8 name; +#define BTF_KFUNCS_START (name) \ +__BTF_SET8_START(name, local, BTF_SET8_KFUNCS) + +#define BTF_KFUNCS_END (name) \ +BTF_SET8_END(name) +#else #define BTF_ID_LIST (name) static u32 __maybe_unused name[64];
@@ -218,6 +227,8 @@ extern struct btf_id_set8 name;#define BTF_SET_END (name)#define BTF_SET8_START (name) static struct btf_id_set8 __maybe_unused name = { 0 };#define BTF_SET8_END (name) +#define BTF_KFUNCS_START (name) static struct btf_id_set8 __maybe_unused name = { 0 }; +#define BTF_KFUNCS_END (name)#endif /* CONFIG_DEBUG_INFO_BTF */
Signature · 1 line
2.42.1
PATCH v3 3/3 bpf: treewide: Annotate BPF kfuncs in BTF
In reply to Daniel XuThis commit marks kfuncs as such inside the .BTF_ids section. The upshot of these annotations is that we'll be able to automatically generate kfunc prototypes for downstream users. The process is as follows:
1. In source, use BTF_KFUNCS_START/END macro pair to mark kfuncs
2. During build, pahole injects into BTF a "bpf_kfunc" BTF_DECL_TAG for each function inside BTF_KFUNCS sets
3. At runtime, vmlinux or module BTF is made available in sysfs
4. At runtime, bpftool (or similar) can look at provided BTF and generate appropriate prototypes for functions with "bpf_kfunc" tag
To ensure future kfunc are similarly tagged, we now also return error inside kfunc registration for untagged kfuncs. For vmlinux kfuncs, we also WARN(), as initcall machinery does not handle errors.
--- drivers/hid/bpf/hid_bpf_dispatch.c | 8 ++++---- fs/verity/measure.c | 4 ++-- kernel/bpf/btf.c | 8 ++++++++ kernel/bpf/cpumask.c | 4 ++-- kernel/bpf/helpers.c | 8 ++++---- kernel/bpf/map_iter.c | 4 ++-- kernel/cgroup/rstat.c | 4 ++-- kernel/trace/bpf_trace.c | 8 ++++---- net/bpf/test_run.c | 8 ++++---- net/core/filter.c | 16 ++++++++-------- net/core/xdp.c | 4 ++-- net/ipv4/bpf_tcp_ca.c | 4 ++-- net/ipv4/fou_bpf.c | 4 ++-- net/ipv4/tcp_bbr.c | 4 ++-- net/ipv4/tcp_cubic.c | 4 ++-- net/ipv4/tcp_dctcp.c | 4 ++-- net/netfilter/nf_conntrack_bpf.c | 4 ++-- net/netfilter/nf_nat_bpf.c | 4 ++-- net/xfrm/xfrm_interface_bpf.c | 4 ++-- net/xfrm/xfrm_state_bpf.c | 4 ++-- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 8 ++++---- 21 files changed, 64 insertions(+), 56 deletions(-)
drivers/hid/bpf/hid_bpf_dispatch.c +4 -4
@@ -172,9 +172,9 @@ hid_bpf_get_data(struct hid_bpf_ctx *ctx, unsigned int offset, const size_t rdwr* The following set contains all functions we agree BPF programs * can use. */ -BTF_SET8_START (hid_bpf_kfunc_ids) +BTF_KFUNCS_START (hid_bpf_kfunc_ids)BTF_ID_FLAGS (func ,hid_bpf_get_data ,KF_RET_NULL ) -BTF_SET8_END (hid_bpf_kfunc_ids) +BTF_KFUNCS_END (hid_bpf_kfunc_ids) static const struct btf_kfunc_id_set hid_bpf_kfunc_set = { .owner =THIS_MODULE ,
@@ -440,12 +440,12 @@ static const struct btf_kfunc_id_set hid_bpf_fmodret_set = { };/* for syscall HID-BPF */ -BTF_SET8_START (hid_bpf_syscall_kfunc_ids) +BTF_KFUNCS_START (hid_bpf_syscall_kfunc_ids)BTF_ID_FLAGS (func ,hid_bpf_attach_prog )BTF_ID_FLAGS (func, hid_bpf_allocate_context,KF_ACQUIRE |KF_RET_NULL )BTF_ID_FLAGS (func, hid_bpf_release_context,KF_RELEASE )BTF_ID_FLAGS (func, hid_bpf_hw_request) -BTF_SET8_END (hid_bpf_syscall_kfunc_ids) +BTF_KFUNCS_END (hid_bpf_syscall_kfunc_ids) static const struct btf_kfunc_id_set hid_bpf_syscall_kfunc_set = { .owner =THIS_MODULE ,
fs/verity/measure.c +2 -2
@@ -159,9 +159,9 @@ __bpf_kfunc int bpf_get_fsverity_digest(struct file *file, struct bpf_dynptr_ker__bpf_kfunc_end_defs (); -BTF_SET8_START (fsverity_set_ids) +BTF_KFUNCS_START (fsverity_set_ids)BTF_ID_FLAGS (func ,bpf_get_fsverity_digest ,KF_TRUSTED_ARGS ) -BTF_SET8_END (fsverity_set_ids) +BTF_KFUNCS_END (fsverity_set_ids) static int bpf_get_fsverity_digest_filter(const struct bpf_prog *prog, u32 kfunc_id) {
kernel/bpf/btf.c +8 -0
@@ -7802,6 +7802,14 @@ int register_btf_kfunc_id_set(enum bpf_prog_type prog_type, {enum btf_kfunc_hook hook; +/* All kfuncs need to be tagged as such in BTF. +* WARN() for initcall registrations that do not check errors. +*/ +if (!(kset->set->flags &BTF_SET8_KFUNCS )) { +WARN_ON (!kset->owner); +return -EINVAL ; + } + hook =bpf_prog_type_to_kfunc_hook (prog_type);return __register_btf_kfunc_id_set (hook, kset); }
kernel/bpf/cpumask.c +2 -2
@@ -424,7 +424,7 @@ __bpf_kfunc u32 bpf_cpumask_weight(const struct cpumask *cpumask)__bpf_kfunc_end_defs (); -BTF_SET8_START(cpumask_kfunc_btf_ids) +BTF_KFUNCS_START(cpumask_kfunc_btf_ids) BTF_ID_FLAGS(func, bpf_cpumask_create, KF_ACQUIRE | KF_RET_NULL) BTF_ID_FLAGS(func, bpf_cpumask_release, KF_RELEASE) BTF_ID_FLAGS(func, bpf_cpumask_acquire, KF_ACQUIRE | KF_TRUSTED_ARGS)
@@ -450,7 +450,7 @@ BTF_ID_FLAGS(func, bpf_cpumask_copy, KF_RCU) BTF_ID_FLAGS(func, bpf_cpumask_any_distribute, KF_RCU) BTF_ID_FLAGS(func, bpf_cpumask_any_and_distribute, KF_RCU) BTF_ID_FLAGS(func, bpf_cpumask_weight, KF_RCU) -BTF_SET8_END (cpumask_kfunc_btf_ids) +BTF_KFUNCS_END (cpumask_kfunc_btf_ids) static const struct btf_kfunc_id_set cpumask_kfunc_set = { .owner =THIS_MODULE ,
kernel/bpf/helpers.c +4 -4
@@ -2543,7 +2543,7 @@ __bpf_kfunc void bpf_throw(u64 cookie)__bpf_kfunc_end_defs (); -BTF_SET8_START(generic_btf_ids) +BTF_KFUNCS_START(generic_btf_ids)#ifdef CONFIG_KEXEC_CORE BTF_ID_FLAGS(func, crash_kexec, KF_DESTRUCTIVE)#endif
@@ -2572,7 +2572,7 @@ BTF_ID_FLAGS(func, bpf_task_get_cgroup1, KF_ACQUIRE | KF_RCU | KF_RET_NULL)#endif BTF_ID_FLAGS(func, bpf_task_from_pid, KF_ACQUIRE | KF_RET_NULL) BTF_ID_FLAGS(func, bpf_throw) -BTF_SET8_END (generic_btf_ids) +BTF_KFUNCS_END (generic_btf_ids) static const struct btf_kfunc_id_set generic_kfunc_set = { .owner =THIS_MODULE ,
@@ -2588,7 +2588,7 @@ BTF_ID(struct, cgroup) BTF_ID(func, bpf_cgroup_release_dtor)#endif -BTF_SET8_START(common_btf_ids) +BTF_KFUNCS_START(common_btf_ids) BTF_ID_FLAGS(func, bpf_cast_to_kern_ctx) BTF_ID_FLAGS(func, bpf_rdonly_cast) BTF_ID_FLAGS(func, bpf_rcu_read_lock)
@@ -2617,7 +2617,7 @@ BTF_ID_FLAGS(func, bpf_dynptr_is_null) BTF_ID_FLAGS(func, bpf_dynptr_is_rdonly) BTF_ID_FLAGS(func, bpf_dynptr_size) BTF_ID_FLAGS(func, bpf_dynptr_clone) -BTF_SET8_END (common_btf_ids) +BTF_KFUNCS_END (common_btf_ids) static const struct btf_kfunc_id_set common_kfunc_set = { .owner =THIS_MODULE ,
kernel/bpf/map_iter.c +2 -2
@@ -213,9 +213,9 @@ __bpf_kfunc s64 bpf_map_sum_elem_count(const struct bpf_map *map)__bpf_kfunc_end_defs (); -BTF_SET8_START (bpf_map_iter_kfunc_ids) +BTF_KFUNCS_START (bpf_map_iter_kfunc_ids)BTF_ID_FLAGS (func ,bpf_map_sum_elem_count ,KF_TRUSTED_ARGS ) -BTF_SET8_END (bpf_map_iter_kfunc_ids) +BTF_KFUNCS_END (bpf_map_iter_kfunc_ids) static const struct btf_kfunc_id_set bpf_map_iter_kfunc_set = { .owner =THIS_MODULE ,
kernel/cgroup/rstat.c +2 -2
@@ -520,10 +520,10 @@ void cgroup_base_stat_cputime_show(struct seq_file *seq) }/* Add bpf kfuncs for cgroup_rstat_updated() and cgroup_rstat_flush() */ -BTF_SET8_START (bpf_rstat_kfunc_ids) +BTF_KFUNCS_START (bpf_rstat_kfunc_ids)BTF_ID_FLAGS (func ,cgroup_rstat_updated )BTF_ID_FLAGS (func, cgroup_rstat_flush,KF_SLEEPABLE ) -BTF_SET8_END (bpf_rstat_kfunc_ids) +BTF_KFUNCS_END (bpf_rstat_kfunc_ids) static const struct btf_kfunc_id_set bpf_rstat_kfunc_set = { .owner =THIS_MODULE ,
kernel/trace/bpf_trace.c +4 -4
@@ -1412,14 +1412,14 @@ __bpf_kfunc int bpf_verify_pkcs7_signature(struct bpf_dynptr_kern *data_ptr,__bpf_kfunc_end_defs (); -BTF_SET8_START(key_sig_kfunc_set) +BTF_KFUNCS_START(key_sig_kfunc_set) BTF_ID_FLAGS(func, bpf_lookup_user_key, KF_ACQUIRE | KF_RET_NULL | KF_SLEEPABLE) BTF_ID_FLAGS(func, bpf_lookup_system_key, KF_ACQUIRE | KF_RET_NULL) BTF_ID_FLAGS(func, bpf_key_put, KF_RELEASE) #ifdef CONFIG_SYSTEM_DATA_VERIFICATION BTF_ID_FLAGS(func, bpf_verify_pkcs7_signature, KF_SLEEPABLE) #endif -BTF_SET8_END(key_sig_kfunc_set) +BTF_KFUNCS_END(key_sig_kfunc_set) static const struct btf_kfunc_id_set bpf_key_sig_kfunc_set = { .owner = THIS_MODULE,
@@ -1475,9 +1475,9 @@ __bpf_kfunc int bpf_get_file_xattr(struct file *file, const char *name__str,__bpf_kfunc_end_defs (); -BTF_SET8_START(fs_kfunc_set_ids) +BTF_KFUNCS_START(fs_kfunc_set_ids) BTF_ID_FLAGS(func, bpf_get_file_xattr, KF_SLEEPABLE | KF_TRUSTED_ARGS) -BTF_SET8_END(fs_kfunc_set_ids) +BTF_KFUNCS_END(fs_kfunc_set_ids) static int bpf_get_file_xattr_filter(const struct bpf_prog *prog, u32 kfunc_id) {
net/bpf/test_run.c +4 -4
@@ -617,21 +617,21 @@ CFI_NOSEAL(bpf_kfunc_call_memb_release_dtor);__bpf_kfunc_end_defs (); -BTF_SET8_START (bpf_test_modify_return_ids) +BTF_KFUNCS_START (bpf_test_modify_return_ids)BTF_ID_FLAGS (func ,bpf_modify_return_test )BTF_ID_FLAGS (func, bpf_modify_return_test2)BTF_ID_FLAGS (func, bpf_fentry_test1,KF_SLEEPABLE ) -BTF_SET8_END (bpf_test_modify_return_ids) +BTF_KFUNCS_END (bpf_test_modify_return_ids) static const struct btf_kfunc_id_set bpf_test_modify_return_set = { .owner =THIS_MODULE , .set = &bpf_test_modify_return_ids, }; -BTF_SET8_START (test_sk_check_kfunc_ids) +BTF_KFUNCS_START (test_sk_check_kfunc_ids) BTF_ID_FLAGS(func, bpf_kfunc_call_test_release, KF_RELEASE) BTF_ID_FLAGS(func, bpf_kfunc_call_memb_release, KF_RELEASE) -BTF_SET8_END(test_sk_check_kfunc_ids) +BTF_KFUNCS_END(test_sk_check_kfunc_ids) static void *bpf_test_init(const union bpf_attr *kattr, u32 user_size,u32 size,u32 headroom,u32 tailroom)
net/core/filter.c +8 -8
@@ -11853,17 +11853,17 @@ int bpf_dynptr_from_skb_rdonly(struct sk_buff *skb, u64 flags,return 0 ; } -BTF_SET8_START (bpf_kfunc_check_set_skb) +BTF_KFUNCS_START (bpf_kfunc_check_set_skb)BTF_ID_FLAGS (func ,bpf_dynptr_from_skb ) -BTF_SET8_END (bpf_kfunc_check_set_skb) +BTF_KFUNCS_END (bpf_kfunc_check_set_skb) -BTF_SET8_START (bpf_kfunc_check_set_xdp) +BTF_KFUNCS_START (bpf_kfunc_check_set_xdp)BTF_ID_FLAGS (func, bpf_dynptr_from_xdp) -BTF_SET8_END (bpf_kfunc_check_set_xdp) +BTF_KFUNCS_END (bpf_kfunc_check_set_xdp) -BTF_SET8_START (bpf_kfunc_check_set_sock_addr) +BTF_KFUNCS_START (bpf_kfunc_check_set_sock_addr)BTF_ID_FLAGS (func, bpf_sock_addr_set_sun_path) -BTF_SET8_END (bpf_kfunc_check_set_sock_addr) +BTF_KFUNCS_END (bpf_kfunc_check_set_sock_addr) static const struct btf_kfunc_id_set bpf_kfunc_set_skb = { .owner =THIS_MODULE ,
@@ -11936,9 +11936,9 @@ __bpf_kfunc int bpf_sock_destroy(struct sock_common *sock)__bpf_kfunc_end_defs (); -BTF_SET8_START (bpf_sk_iter_kfunc_ids) +BTF_KFUNCS_START (bpf_sk_iter_kfunc_ids)BTF_ID_FLAGS (func ,bpf_sock_destroy ,KF_TRUSTED_ARGS ) -BTF_SET8_END (bpf_sk_iter_kfunc_ids) +BTF_KFUNCS_END (bpf_sk_iter_kfunc_ids) static int tracing_iter_filter(const struct bpf_prog *prog, u32 kfunc_id) {
net/core/xdp.c +2 -2
@@ -771,11 +771,11 @@ __bpf_kfunc int bpf_xdp_metadata_rx_vlan_tag(const struct xdp_md *ctx,__bpf_kfunc_end_defs (); -BTF_SET8_START (xdp_metadata_kfunc_ids) +BTF_KFUNCS_START (xdp_metadata_kfunc_ids) #define XDP_METADATA_KFUNC(_, __, name, ___) BTF_ID_FLAGS(func, name, KF_TRUSTED_ARGS) XDP_METADATA_KFUNC_xxx #undef XDP_METADATA_KFUNC -BTF_SET8_END (xdp_metadata_kfunc_ids) +BTF_KFUNCS_END (xdp_metadata_kfunc_ids) static const struct btf_kfunc_id_set xdp_metadata_kfunc_set = { .owner =THIS_MODULE ,
net/ipv4/bpf_tcp_ca.c +2 -2
@@ -195,13 +195,13 @@ bpf_tcp_ca_get_func_proto(enum bpf_func_id func_id, } } -BTF_SET8_START (bpf_tcp_ca_check_kfunc_ids) +BTF_KFUNCS_START (bpf_tcp_ca_check_kfunc_ids)BTF_ID_FLAGS (func ,tcp_reno_ssthresh )BTF_ID_FLAGS (func, tcp_reno_cong_avoid)BTF_ID_FLAGS (func, tcp_reno_undo_cwnd)BTF_ID_FLAGS (func, tcp_slow_start)BTF_ID_FLAGS (func, tcp_cong_avoid_ai) -BTF_SET8_END (bpf_tcp_ca_check_kfunc_ids) +BTF_KFUNCS_END (bpf_tcp_ca_check_kfunc_ids) static const struct btf_kfunc_id_set bpf_tcp_ca_kfunc_set = { .owner =THIS_MODULE ,
net/ipv4/fou_bpf.c +2 -2
@@ -100,10 +100,10 @@ __bpf_kfunc int bpf_skb_get_fou_encap(struct __sk_buff *skb_ctx,__bpf_kfunc_end_defs (); -BTF_SET8_START (fou_kfunc_set) +BTF_KFUNCS_START (fou_kfunc_set)BTF_ID_FLAGS (func ,bpf_skb_set_fou_encap )BTF_ID_FLAGS (func, bpf_skb_get_fou_encap) -BTF_SET8_END (fou_kfunc_set) +BTF_KFUNCS_END (fou_kfunc_set) static const struct btf_kfunc_id_set fou_bpf_kfunc_set = { .owner =THIS_MODULE ,
net/ipv4/tcp_bbr.c +2 -2
@@ -1155,7 +1155,7 @@ static struct tcp_congestion_ops tcp_bbr_cong_ops __read_mostly = { .set_state = bbr_set_state, }; -BTF_SET8_START(tcp_bbr_check_kfunc_ids) +BTF_KFUNCS_START(tcp_bbr_check_kfunc_ids)#ifdef CONFIG_X86 #ifdef CONFIG_DYNAMIC_FTRACE BTF_ID_FLAGS (func, bbr_init)
@@ -1168,7 +1168,7 @@ BTF_ID_FLAGS(func, bbr_min_tso_segs) BTF_ID_FLAGS(func, bbr_set_state)#endif #endif -BTF_SET8_END (tcp_bbr_check_kfunc_ids) +BTF_KFUNCS_END (tcp_bbr_check_kfunc_ids) static const struct btf_kfunc_id_set tcp_bbr_kfunc_set = { .owner =THIS_MODULE ,
net/ipv4/tcp_cubic.c +2 -2
@@ -485,7 +485,7 @@ static struct tcp_congestion_ops cubictcp __read_mostly = { .name = "cubic", }; -BTF_SET8_START(tcp_cubic_check_kfunc_ids) +BTF_KFUNCS_START(tcp_cubic_check_kfunc_ids)#ifdef CONFIG_X86 #ifdef CONFIG_DYNAMIC_FTRACE BTF_ID_FLAGS (func, cubictcp_init)
@@ -496,7 +496,7 @@ BTF_ID_FLAGS(func, cubictcp_cwnd_event) BTF_ID_FLAGS(func, cubictcp_acked)#endif #endif -BTF_SET8_END (tcp_cubic_check_kfunc_ids) +BTF_KFUNCS_END (tcp_cubic_check_kfunc_ids) static const struct btf_kfunc_id_set tcp_cubic_kfunc_set = { .owner =THIS_MODULE ,
net/ipv4/tcp_dctcp.c +2 -2
@@ -260,7 +260,7 @@ static struct tcp_congestion_ops dctcp_reno __read_mostly = { .name = "dctcp-reno", }; -BTF_SET8_START(tcp_dctcp_check_kfunc_ids) +BTF_KFUNCS_START(tcp_dctcp_check_kfunc_ids)#ifdef CONFIG_X86 #ifdef CONFIG_DYNAMIC_FTRACE BTF_ID_FLAGS (func, dctcp_init)
@@ -271,7 +271,7 @@ BTF_ID_FLAGS(func, dctcp_cwnd_undo) BTF_ID_FLAGS(func, dctcp_state)#endif #endif -BTF_SET8_END (tcp_dctcp_check_kfunc_ids) +BTF_KFUNCS_END (tcp_dctcp_check_kfunc_ids) static const struct btf_kfunc_id_set tcp_dctcp_kfunc_set = { .owner =THIS_MODULE ,
net/netfilter/nf_conntrack_bpf.c +2 -2
@@ -467,7 +467,7 @@ __bpf_kfunc int bpf_ct_change_status(struct nf_conn *nfct, u32 status)__bpf_kfunc_end_defs (); -BTF_SET8_START(nf_ct_kfunc_set) +BTF_KFUNCS_START(nf_ct_kfunc_set) BTF_ID_FLAGS(func, bpf_xdp_ct_alloc, KF_ACQUIRE | KF_RET_NULL) BTF_ID_FLAGS(func, bpf_xdp_ct_lookup, KF_ACQUIRE | KF_RET_NULL) BTF_ID_FLAGS(func, bpf_skb_ct_alloc, KF_ACQUIRE | KF_RET_NULL)
@@ -478,7 +478,7 @@ BTF_ID_FLAGS(func, bpf_ct_set_timeout, KF_TRUSTED_ARGS) BTF_ID_FLAGS(func, bpf_ct_change_timeout, KF_TRUSTED_ARGS) BTF_ID_FLAGS(func, bpf_ct_set_status, KF_TRUSTED_ARGS) BTF_ID_FLAGS(func, bpf_ct_change_status, KF_TRUSTED_ARGS) -BTF_SET8_END (nf_ct_kfunc_set) +BTF_KFUNCS_END (nf_ct_kfunc_set) static const struct btf_kfunc_id_set nf_conntrack_kfunc_set = { .owner =THIS_MODULE ,
net/netfilter/nf_nat_bpf.c +2 -2
@@ -54,9 +54,9 @@ __bpf_kfunc int bpf_ct_set_nat_info(struct nf_conn___init *nfct,__bpf_kfunc_end_defs (); -BTF_SET8_START (nf_nat_kfunc_set) +BTF_KFUNCS_START (nf_nat_kfunc_set)BTF_ID_FLAGS (func ,bpf_ct_set_nat_info ,KF_TRUSTED_ARGS ) -BTF_SET8_END (nf_nat_kfunc_set) +BTF_KFUNCS_END (nf_nat_kfunc_set) static const struct btf_kfunc_id_set nf_bpf_nat_kfunc_set = { .owner =THIS_MODULE ,
net/xfrm/xfrm_interface_bpf.c +2 -2
@@ -93,10 +93,10 @@ __bpf_kfunc int bpf_skb_set_xfrm_info(struct __sk_buff *skb_ctx, const struct bp__bpf_kfunc_end_defs (); -BTF_SET8_START (xfrm_ifc_kfunc_set) +BTF_KFUNCS_START (xfrm_ifc_kfunc_set)BTF_ID_FLAGS (func ,bpf_skb_get_xfrm_info )BTF_ID_FLAGS (func, bpf_skb_set_xfrm_info) -BTF_SET8_END (xfrm_ifc_kfunc_set) +BTF_KFUNCS_END (xfrm_ifc_kfunc_set) static const struct btf_kfunc_id_set xfrm_interface_kfunc_set = { .owner =THIS_MODULE ,
net/xfrm/xfrm_state_bpf.c +2 -2
@@ -117,10 +117,10 @@ __bpf_kfunc void bpf_xdp_xfrm_state_release(struct xfrm_state *x)__bpf_kfunc_end_defs (); -BTF_SET8_START(xfrm_state_kfunc_set) +BTF_KFUNCS_START(xfrm_state_kfunc_set) BTF_ID_FLAGS(func, bpf_xdp_get_xfrm_state, KF_RET_NULL | KF_ACQUIRE) BTF_ID_FLAGS(func, bpf_xdp_xfrm_state_release, KF_RELEASE) -BTF_SET8_END(xfrm_state_kfunc_set) +BTF_KFUNCS_END(xfrm_state_kfunc_set) static const struct btf_kfunc_id_set xfrm_state_xdp_kfunc_set = { .owner = THIS_MODULE,
tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c +4 -4
@@ -341,12 +341,12 @@ static struct bin_attribute bin_attr_bpf_testmod_file __ro_after_init = { .write = bpf_testmod_test_write, }; -BTF_SET8_START (bpf_testmod_common_kfunc_ids) +BTF_KFUNCS_START (bpf_testmod_common_kfunc_ids)BTF_ID_FLAGS (func ,bpf_iter_testmod_seq_new ,KF_ITER_NEW )BTF_ID_FLAGS (func, bpf_iter_testmod_seq_next,KF_ITER_NEXT |KF_RET_NULL )BTF_ID_FLAGS (func, bpf_iter_testmod_seq_destroy,KF_ITER_DESTROY )BTF_ID_FLAGS (func, bpf_kfunc_common_test) -BTF_SET8_END (bpf_testmod_common_kfunc_ids) +BTF_KFUNCS_END (bpf_testmod_common_kfunc_ids) static const struct btf_kfunc_id_set bpf_testmod_common_kfunc_set = { .owner =THIS_MODULE ,
@@ -492,7 +492,7 @@ __bpf_kfunc static u32 bpf_kfunc_call_test_static_unused_arg(u32 arg, u32 unusedreturn arg; } -BTF_SET8_START(bpf_testmod_check_kfunc_ids) +BTF_KFUNCS_START(bpf_testmod_check_kfunc_ids) BTF_ID_FLAGS(func, bpf_testmod_test_mod_kfunc) BTF_ID_FLAGS(func, bpf_kfunc_call_test1) BTF_ID_FLAGS(func, bpf_kfunc_call_test2)
@@ -518,7 +518,7 @@ BTF_ID_FLAGS(func, bpf_kfunc_call_test_ref, KF_TRUSTED_ARGS | KF_RCU) BTF_ID_FLAGS(func, bpf_kfunc_call_test_destructive, KF_DESTRUCTIVE) BTF_ID_FLAGS(func, bpf_kfunc_call_test_static_unused_arg) BTF_ID_FLAGS(func, bpf_kfunc_call_test_offset) -BTF_SET8_END (bpf_testmod_check_kfunc_ids) +BTF_KFUNCS_END (bpf_testmod_check_kfunc_ids) static const struct btf_kfunc_id_set bpf_testmod_kfunc_set = { .owner =THIS_MODULE ,
Signature · 1 line
2.42.1
Re: [PATCH bpf-next v3 2/3] bpf: btf: Add BTF_KFUNCS_START/END macro pair
In reply to Daniel XuQuoted 16 lines · Daniel Xu
This macro pair is functionally equivalent to BTF_SET8_START/END, except with
BTF_SET8_KFUNCSflag set in thebtf_id_set8flags field. The next commit will codemod all kfunc set8s to this new variant such that all kfuncs are tagged as such in .BTF_ids section.Signed-off-by Daniel Xu <[email protected]>--- include/linux/btf_ids.h | 11 +++++++++++ 1 file changed, 11 insertions(+)include/linux/btf_ids.h +0
-0
include/linux/btf_ids.h struct btf_id_set { · line 12
Quoted 5 lines
include/linux/btf_ids.h +2
-0@@ -8,6 +8,9 @@ struct btf_id_set {u32 ids[]; }; +/* This flag implies BTF_SET8 holds kfunc(s) */ +#define BTF_SET8_KFUNCS (1 << 0)
Nit: could this be an enum so that the flag is discoverable via BTF? Also, isn't this UAPI if pahole interprets this flag?
Quoted 9 lines · Daniel Xu
=== Description ===
This is a bpf-treewide change that annotates all kfuncs as such inside .BTF_ids. This annotation eventually allows us to automatically generate kfunc prototypes from bpftool.
We store this metadata inside a yet-unused flags field inside struct
btf_id_set8(thanks Kumar!). pahole will be taught where to look.
This is great, thanks for tackling this. With yout patches we can figure out the full set of kfuncs. Is there a way to extend it so that we can tell which program context a kfunc can be called from?
Hi Lorenz,
Quoted 8 lines · Lorenz Bauer
Quoted 7 lines · Daniel Xu
=== Description ===
This is a bpf-treewide change that annotates all kfuncs as such inside .BTF_ids. This annotation eventually allows us to automatically generate kfunc prototypes from bpftool.
Quoted 6 lines
Quoted 2 lines
We store this metadata inside a yet-unused flags field inside struct
btf_id_set8(thanks Kumar!). pahole will be taught where to look.This is great, thanks for tackling this. With yout patches we can figure out the full set of kfuncs. Is there a way to extend it so that we can tell which program context a kfunc can be called from?
I think a potential approach would be to extend BTF_ID_FLAGS() with some more flags if we want to continue with .BTF_ids parsing technique. But it has some issues with program-type-less helpers that are associated with attachpoints as well as struct_ops helpers.
Since it looks like we're in rather early stages of program-type-less world, maybe it'd be good to defer solving this problem until more use cases are established and we can find a good cut point to design around. Even with uapi helpers there was no way before.
Thanks,
Daniel
Re: [PATCH bpf-next v3 2/3] bpf: btf: Add BTF_KFUNCS_START/END macro pair
In reply to Lorenz BauerQuoted 20 lines · Lorenz Bauer
Quoted 19 lines · Daniel Xu
This macro pair is functionally equivalent to BTF_SET8_START/END, except with
BTF_SET8_KFUNCSflag set in thebtf_id_set8flags field. The next commit will codemod all kfunc set8s to this new variant such that all kfuncs are tagged as such in .BTF_ids section.Signed-off-by Daniel Xu <[email protected]>--- include/linux/btf_ids.h | 11 +++++++++++ 1 file changed, 11 insertions(+)include/linux/btf_ids.h +0
-0@@ -8,6 +8,9 @@ struct btf_id_set {u32 ids[]; };
Quoted 4 lines
include/linux/btf_ids.h struct btf_id_set { · line 12
Quoted 2 lines
include/linux/btf_ids.h +2
-0+/* This flag implies BTF_SET8 holds kfunc(s) */ +#define BTF_SET8_KFUNCS (1 << 0)Nit: could this be an enum so that the flag is discoverable via BTF?
Sure, makes sense.
Quoted 1 line
Also, isn't this UAPI if pahole interprets this flag?
Not sure. I guess it'd fall under same category as any of the structs the kernel lays out in .BTF_ids, like struct btf_id_set8. IMO it's not, as that's kinda confusing to call anything in ELF uapi. Eg I don't think people would consider layout of .data..percpu section uapi.
Thanks,
Daniel
Re: [PATCH bpf-next v3 2/3] bpf: btf: Add BTF_KFUNCS_START/END macro pair
Quoted 21 lines · Daniel Xu
Quoted 20 lines · Lorenz Bauer
Quoted 19 lines · Daniel Xu
This macro pair is functionally equivalent to BTF_SET8_START/END, except with
BTF_SET8_KFUNCSflag set in thebtf_id_set8flags field. The next commit will codemod all kfunc set8s to this new variant such that all kfuncs are tagged as such in .BTF_ids section.Signed-off-by Daniel Xu <[email protected]>--- include/linux/btf_ids.h | 11 +++++++++++ 1 file changed, 11 insertions(+)include/linux/btf_ids.h +0
-0@@ -8,6 +8,9 @@ struct btf_id_set {u32 ids[]; };
Quoted 6 lines
Quoted 4 lines
include/linux/btf_ids.h struct btf_id_set { · line 12
Quoted 2 lines
include/linux/btf_ids.h +2
-0+/* This flag implies BTF_SET8 holds kfunc(s) */ +#define BTF_SET8_KFUNCS (1 << 0)Nit: could this be an enum so that the flag is discoverable via BTF?
Sure, makes sense.
I took a look - don't think we can make it an enum. See include/linux/btf.h:
/* These need to be macros, as the expressions are used in assembler input */
#define KF_ACQUIRE (1 << 0) /* kfunc is an acquire function */
#define KF_RELEASE (1 << 1) /* kfunc is a release function */
[..]Could do some redefines but maybe not worth it. The new flag is a pretty deep impl detail anyways.
Thanks,
Daniel
Quoted 6 lines · Daniel Xu
=== Description ===
This is a bpf-treewide change that annotates all kfuncs as such inside .BTF_ids. This annotation eventually allows us to automatically generate kfunc prototypes from bpftool.
Quoted 8 lines
We store this metadata inside a yet-unused flags field inside struct
btf_id_set8(thanks Kumar!). pahole will be taught where to look.More details about the full chain of events are available in commit 3's description.
The accompanying pahole changes (still needs some cleanup) can be viewed here on this "frozen" branch [0].
so the plan is to have bpftool support to generate header file with detected kfuncs?
jirka
Quoted 46 lines
[0]: https://github.com/danobi/pahole/tree/kfunc_btf-mailed
=== Changelog ===
Changes from v2:
* OnlyWARN()for vmlinux kfuncsChanges from v1:
* MoveWARN_ON()up a call level
* Also return error when kfunc set is not properly tagged
* Use BTF_KFUNCS_START/END instead of flags
* RenameBTF_SET8_KFUNCtoBTF_SET8_KFUNCSDaniel Xu (3):
bpf: btf: Support flags forBTF_SET8sets
bpf: btf: Add BTF_KFUNCS_START/END macro pair
bpf: treewide: Annotate BPF kfuncs in BTFdrivers/hid/bpf/hid_bpf_dispatch.c | 8 +++---- fs/verity/measure.c | 4 ++-- include/linux/btf_ids.h | 21 +++++++++++++++---- kernel/bpf/btf.c | 8 +++++++ kernel/bpf/cpumask.c | 4 ++-- kernel/bpf/helpers.c | 8 +++---- kernel/bpf/map_iter.c | 4 ++-- kernel/cgroup/rstat.c | 4 ++-- kernel/trace/bpf_trace.c | 8 +++---- net/bpf/test_run.c | 8 +++---- net/core/filter.c | 16 +++++++------- net/core/xdp.c | 4 ++-- net/ipv4/bpf_tcp_ca.c | 4 ++-- net/ipv4/fou_bpf.c | 4 ++-- net/ipv4/tcp_bbr.c | 4 ++-- net/ipv4/tcp_cubic.c | 4 ++-- net/ipv4/tcp_dctcp.c | 4 ++-- net/netfilter/nf_conntrack_bpf.c | 4 ++-- net/netfilter/nf_nat_bpf.c | 4 ++-- net/xfrm/xfrm_interface_bpf.c | 4 ++-- net/xfrm/xfrm_state_bpf.c | 4 ++-- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 8 +++---- 22 files changed, 81 insertions(+), 60 deletions(-)Signature · 1 line
2.42.1
Quoted 10 lines · Jiri Olsa
Quoted 9 lines · Daniel Xu
=== Description ===
This is a bpf-treewide change that annotates all kfuncs as such inside .BTF_ids. This annotation eventually allows us to automatically generate kfunc prototypes from bpftool.
We store this metadata inside a yet-unused flags field inside struct
btf_id_set8(thanks Kumar!). pahole will be taught where to look.
Quoted 8 lines
Quoted 5 lines
More details about the full chain of events are available in commit 3's description.
The accompanying pahole changes (still needs some cleanup) can be viewed here on this "frozen" branch [0].
so the plan is to have bpftool support to generate header file with detected kfuncs?
Yep, that's the major use case. But I see other use cases as well like precision probing of kfuncs. Rather than guess and check which progs can load (in the event of backwards incompatible kfunc changes), programs can look at kfunc type signature thru BTF.
Quoted 14 lines · Daniel Xu
Quoted 13 lines · Jiri Olsa
Quoted 12 lines · Daniel Xu
=== Description ===
This is a bpf-treewide change that annotates all kfuncs as such inside .BTF_ids. This annotation eventually allows us to automatically generate kfunc prototypes from bpftool.
We store this metadata inside a yet-unused flags field inside struct
btf_id_set8(thanks Kumar!). pahole will be taught where to look.More details about the full chain of events are available in commit 3's description.
Quoted 7 lines
Quoted 5 lines
Quoted 2 lines
The accompanying pahole changes (still needs some cleanup) can be viewed here on this "frozen" branch [0].
so the plan is to have bpftool support to generate header file with detected kfuncs?
Yep, that's the major use case. But I see other use cases as well like
ok, any chance you could already include it in the patchset? would be a great way to test this.. maybe we could change selftests to use that
thanks,
jirka
Quoted 3 lines
precision probing of kfuncs. Rather than guess and check which progs can load (in the event of backwards incompatible kfunc changes), programs can look at kfunc type signature thru BTF.
Hi Jiri,
Quoted 18 lines · Jiri Olsa
Quoted 17 lines · Daniel Xu
Quoted 16 lines · Jiri Olsa
Quoted 14 lines · Daniel Xu
=== Description ===
This is a bpf-treewide change that annotates all kfuncs as such inside .BTF_ids. This annotation eventually allows us to automatically generate kfunc prototypes from bpftool.
We store this metadata inside a yet-unused flags field inside struct
btf_id_set8(thanks Kumar!). pahole will be taught where to look.More details about the full chain of events are available in commit 3's description.
The accompanying pahole changes (still needs some cleanup) can be viewed here on this "frozen" branch [0].
Quoted 8 lines
Quoted 4 lines
Quoted 2 lines
so the plan is to have bpftool support to generate header file with detected kfuncs?
Yep, that's the major use case. But I see other use cases as well like
ok, any chance you could already include it in the patchset? would be a great way to test this.. maybe we could change selftests to use that
I haven't start working on that code yet, but I can.
Here is my plan FWIW:
1. Bump minimum required pahole version up. Or feature probe for kfunc decl tag support. Whatever is the standard practice here.
2. Teach bpftool to dump kfunc prototypes, guarded behind a flag.
3. Flip bpftool flag on in selftest build and remove all manual kfunc prototypes atomically in 1 commit.
I thought it'd be nicer to do it incrementally given all the moving pieces. But if we want to land it all at once that is ok by me too.
Thanks,
Daniel
Quoted 37 lines · Daniel Xu
Hi Jiri,
Quoted 18 lines · Jiri Olsa
Quoted 17 lines · Daniel Xu
Quoted 16 lines · Jiri Olsa
Quoted 14 lines · Daniel Xu
=== Description ===
This is a bpf-treewide change that annotates all kfuncs as such inside .BTF_ids. This annotation eventually allows us to automatically generate kfunc prototypes from bpftool.
We store this metadata inside a yet-unused flags field inside struct
btf_id_set8(thanks Kumar!). pahole will be taught where to look.More details about the full chain of events are available in commit 3's description.
The accompanying pahole changes (still needs some cleanup) can be viewed here on this "frozen" branch [0].
Quoted 8 lines
Quoted 4 lines
Quoted 2 lines
so the plan is to have bpftool support to generate header file with detected kfuncs?
Yep, that's the major use case. But I see other use cases as well like
ok, any chance you could already include it in the patchset? would be a great way to test this.. maybe we could change selftests to use that
I haven't start working on that code yet, but I can.
Here is my plan FWIW:
1. Bump minimum required pahole version up. Or feature probe for kfunc decl tag support. Whatever is the standard practice here.
Quoted 7 lines
2. Teach bpftool to dump kfunc prototypes, guarded behind a flag.
3. Flip bpftool flag on in selftest build and remove all manual kfunc prototypes atomically in 1 commit.
I thought it'd be nicer to do it incrementally given all the moving pieces. But if we want to land it all at once that is ok by me too.
I think it'd be best to try the whole thing before we merge the change to pahole.. I guess the tests changes can come later, but would be great to try the kfunc dump and make sure it works as expected
jirka