Support kernel module function calls from eBPF
Subsystems (10)
Kumar Kartikeya Dwivedi
maintainerv7 cover Support kernel module function calls from eBPF
This set enables kernel module function calls, and also modifies verifier logic to permit invalid kernel function calls as long as they are pruned as part of dead code elimination. This is done to provide better runtime portability for BPF objects, which can conditionally disable parts of code that are pruned later by the verifier (e.g. const volatile vars, kconfig options). libbpf modifications are made along with kernel changes to support module function calls.
It also converts TCP congestion control objects to use the module kfunc support instead of relying on IS_BUILTIN ifdef.
Changelog:
----------
v6 -> v7
v6: https://lore.kernel.org/bpf/[email protected]
* Let __bpf_check_kfunc_call take kfunc_btf_id_list instead of generating callbacks (Andrii)
* Rename it to bpf_check_mod_kfunc_call to reflect usage
* Remove OOM checks (Alexei)
* Remove resolve_btfids invocation for bpf_testmod (Andrii)
* Move fd_array_cnt initialization near fd_array alloc (Andrii)
* Rename helper to btf_find_by_name_kind and pass start_id (Andrii)
* memset when data is NULL in add_data (Alexei)
* Fix other nits
v5 -> v6
v5: https://lore.kernel.org/bpf/[email protected]
* Rework gen_loader relocation emits
* Only emit bpf_btf_find_by_name_kind call when required (Alexei)
* Refactor code to emit ksym var and func relo into separate helpers, this will be easier to add future weak/typeless ksym support to (for my followup)
* Count references for both ksym var and funcs, and avoid calling helpers unless required for both of them. This also means we share fds between ksym vars for the module BTFs. Also be careful with this when closing BTF fd so that we only close one instance of the fd for each ksym
v4 -> v5
v4: https://lore.kernel.org/bpf/[email protected]
* Address comments from Alexei
* Use reserved fd_array area in loader map instead of creating a new map
* Drop selftest testing the 256 kfunc limit, however selftest testing reuse of BTF fd for same kfunc in gen_loader and libbpf is kept
* Address comments from Andrii
* Make --no-fail the default for resolve_btfids, i.e. only fail if we find BTF section and cannot process it
* Use obj->btf_modules array to store index in the fd_array, so that we don't have to do any searching to reuse the index, instead only set it the first time a module BTF's fd is used
* Make find_ksym_btf_id to return struct module_btf * in last parameter
* Improve logging when index becomes bigger than INT16_MAX
* Add btf__find_by_name_kind_own internal helper to only start searching for kfunc ID in module BTF, since find_ksym_btf_id already checks vmlinux BTF before iterating over module BTFs.
* Fix various other nits
* Fixes for failing selftests on BPF CI
* Rearrange/cleanup selftests
* Avoid testing kfunc limit (Alexei)
* Do test gen_loader and libbpf BTF fd index dedup with 256 calls
* Move invalid kfunc failure test to verifier selftest
* Minimize duplication
* Use consistent bpf_<type>_check_kfunc_call naming for module kfunc callback
* Since we try to add fd using add_data while we can, cherry pick Alexei's patch from CO-RE RFC series to align gen_loader data.
v3 -> v4
v3: https://lore.kernel.org/bpf/[email protected]
* Address comments from Alexei
* Drop MAX_BPF_STACK change, instead move map_fd and BTF fd to BPF array map and pass fd_array using BPF_PSEUDO_MAP_IDX_VALUE
* Address comments from Andrii
* Fix selftest to store to variable for observing function call instead of printk and polluting CI logs
* Drop use of raw_tp for testing, instead reuse classifier based prog_test_run
* Drop index + 1 based insn->off convention for kfunc module calls
* Expand selftests to cover more corner cases
* Misc cleanups
v2 -> v3
v2: https://lore.kernel.org/bpf/[email protected]
* Fix issues pointed out by Kernel Test Robot
* Fix find_kfunc_desc to also take offset into consideration when comparing
RFC v1 -> v2
v1: https://lore.kernel.org/bpf/[email protected]
* Address comments from Alexei
* Reuse fd_array instead of introducing kfunc_btf_fds array
* Take btf and module reference as needed, instead of preloading
* Add BTF_KIND_FUNC relocation support to gen_loader infrastructure
* Address comments from Andrii
* Drop hashmap in libbpf for finding index of existing BTF in fd_array
* Preserve invalid kfunc calls only when the symbol is weak
* Adjust verifier selftests
Kumar Kartikeya Dwivedi (9):
bpf: Introduce BPF support for kernel module function calls
bpf: Be conservative while processing invalid kfunc calls
bpf: btf: Introduce helpers for dynamic BTF set registration
tools: Allow specifying base BTF file in resolve_btfids
bpf: Enable TCP congestion control kfunc from modules
libbpf: Support kernel module function calls
libbpf: Resolve invalid weak kfunc calls with imm = 0, off = 0
libbpf: Update gen_loader to emit BTF_KIND_FUNC relocations
bpf: selftests: Add selftests for module kfunc support
include/linux/bpf.h | 8 +- include/linux/bpf_verifier.h | 2 + include/linux/bpfptr.h | 1 + include/linux/btf.h | 39 +++ kernel/bpf/btf.c | 55 +++ kernel/bpf/core.c | 4 + kernel/bpf/verifier.c | 220 ++++++++++-- net/bpf/test_run.c | 7 +- net/ipv4/bpf_tcp_ca.c | 36 +- net/ipv4/tcp_bbr.c | 28 +- net/ipv4/tcp_cubic.c | 26 +- net/ipv4/tcp_dctcp.c | 26 +- scripts/Makefile.modfinal | 1 + tools/bpf/resolve_btfids/main.c | 28 +- tools/lib/bpf/bpf.c | 1 + tools/lib/bpf/bpf_gen_internal.h | 16 +- tools/lib/bpf/btf.c | 18 +- tools/lib/bpf/gen_loader.c | 314 +++++++++++++++--- tools/lib/bpf/libbpf.c | 104 ++++-- tools/lib/bpf/libbpf_internal.h | 3 + tools/testing/selftests/bpf/Makefile | 9 +- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 23 +- .../selftests/bpf/prog_tests/ksyms_module.c | 29 +- .../bpf/prog_tests/ksyms_module_libbpf.c | 28 ++ .../selftests/bpf/progs/test_ksyms_module.c | 46 ++- tools/testing/selftests/bpf/verifier/calls.c | 23 ++ 26 files changed, 896 insertions(+), 199 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/ksyms_module_libbpf.c
Signature · 1 line
2.33.0
Kumar Kartikeya Dwivedi
maintainerPATCH v7 1/9 bpf: Introduce BPF support for kernel module function calls
This change adds support on the kernel side to allow for BPF programs to call kernel module functions. Userspace will prepare an array of module BTF fds that is passed in during BPF_PROG_LOAD using fd_array parameter. In the kernel, the module BTFs are placed in the auxilliary struct for bpf_prog, and loaded as needed.
The verifier then uses insn->off to index into the fd_array. insn->off 0 is reserved for vmlinux BTF (for backwards compat), so userspace must use an fd_array index > 0 for module kfunc support. kfunc_btf_tab is sorted based on offset in an array, and each offset corresponds to one descriptor, with a max limit up to 256 such module BTFs.
We also change existing kfunc_tab to distinguish each element based on imm, off pair as each such call will now be distinct.
Another change is to check_kfunc_call callback, which now include a struct module * pointer, this is to be used in later patch such that the kfunc_id and module pointer are matched for dynamically registered BTF sets from loadable modules, so that same kfunc_id in two modules doesn't lead to check_kfunc_call succeeding. For the duration of the check_kfunc_call, the reference to struct module exists, as it returns the pointer stored in kfunc_btf_tab.
--- include/linux/bpf.h | 8 +- include/linux/bpf_verifier.h | 2 + kernel/bpf/core.c | 4 + kernel/bpf/verifier.c | 202 ++++++++++++++++++++++++++++++----- net/bpf/test_run.c | 2 +- net/ipv4/bpf_tcp_ca.c | 2 +- 6 files changed, 188 insertions(+), 32 deletions(-)
include/linux/bpf.h +5 -3
@@ -513,7 +513,7 @@ struct bpf_verifier_ops { const struct btf_type *t, int off, int size, enum bpf_access_type atype, u32 *next_btf_id); -bool (*check_kfunc_call)(u32 kfunc_btf_id); +bool (*check_kfunc_call)(u32 kfunc_btf_id,struct module *owner); };struct bpf_prog_offload_ops {
@@ -876,6 +876,7 @@ struct bpf_prog_aux {void *jit_data;/* JIT specific data. arch dependent */ struct bpf_jit_poke_descriptor *poke_tab;struct bpf_kfunc_desc_tab *kfunc_tab; +struct bpf_kfunc_btf_tab *kfunc_btf_tab;u32 size_poke_tab;struct bpf_ksym ksym;const struct bpf_prog_ops *ops;
@@ -1638,7 +1639,7 @@ 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); -bool bpf_prog_test_check_kfunc_call (u32 kfunc_id); +bool bpf_prog_test_check_kfunc_call (u32 kfunc_id,struct module *owner);bool btf_ctx_access (int off,int size,enum bpf_access_type type,const struct bpf_prog *prog,struct bpf_insn_access_aux *info);
@@ -1859,7 +1860,8 @@ static inline int bpf_prog_test_run_sk_lookup(struct bpf_prog *prog,return -ENOTSUPP ; } -static inline bool bpf_prog_test_check_kfunc_call (u32 kfunc_id) +static inline bool bpf_prog_test_check_kfunc_call (u32 kfunc_id, +struct module *owner) {return false; }
include/linux/bpf_verifier.h +2 -0
@@ -527,5 +527,7 @@ int bpf_check_attach_target(struct bpf_verifier_log *log,const struct bpf_prog *tgt_prog, u32 btf_id, struct bpf_attach_target_info *tgt_info); +void bpf_free_kfunc_btf_tab (struct bpf_kfunc_btf_tab *tab); +#endif /* _LINUX_BPF_VERIFIER_H */
kernel/bpf/core.c +4 -0
@@ -32,6 +32,7 @@#include <linux/perf_event.h> #include <linux/extable.h> #include <linux/log2.h> +#include <linux/bpf_verifier.h> #include <asm/barrier.h> #include <asm/unaligned.h>
@@ -2255,6 +2256,9 @@ static void bpf_prog_free_deferred(struct work_struct *work)int i; aux = container_of(work, struct bpf_prog_aux, work); +#ifdef CONFIG_BPF_SYSCALL +bpf_free_kfunc_btf_tab (aux->kfunc_btf_tab); +#endif bpf_free_used_maps (aux);bpf_free_used_btfs (aux);if (bpf_prog_is_dev_bound (aux))
kernel/bpf/verifier.c +175 -27
357 lines not on this page · raw message
net/bpf/test_run.c +1 -1
@@ -241,7 +241,7 @@ BTF_ID(func, bpf_kfunc_call_test2) BTF_ID(func, bpf_kfunc_call_test3)BTF_SET_END (test_sk_kfunc_ids) -bool bpf_prog_test_check_kfunc_call(u32 kfunc_id) +bool bpf_prog_test_check_kfunc_call(u32 kfunc_id, struct module *owner) {return btf_id_set_contains (&test_sk_kfunc_ids, kfunc_id); }
net/ipv4/bpf_tcp_ca.c +1 -1
@@ -255,7 +255,7 @@ BTF_ID(func, bbr_set_state)#endif /* CONFIG_X86 */ BTF_SET_END (bpf_tcp_ca_kfunc_ids) -static bool bpf_tcp_ca_check_kfunc_call(u32 kfunc_btf_id) +static bool bpf_tcp_ca_check_kfunc_call(u32 kfunc_btf_id, struct module *owner) {return btf_id_set_contains (&bpf_tcp_ca_kfunc_ids, kfunc_btf_id); }
Signature · 1 line
2.33.0
Kumar Kartikeya Dwivedi
maintainerPATCH v7 2/9 bpf: Be conservative while processing invalid kfunc calls
In reply to Kumar Kartikeya DwivediThis patch also modifies the BPF verifier to only return error for invalid kfunc calls specially marked by userspace (with insn->imm == 0, insn->off == 0) after the verifier has eliminated dead instructions. This can be handled in the fixup stage, and skip processing during add and check stages.
If such an invalid call is dropped, the fixup stage will not encounter insn->imm as 0, otherwise it bails out and returns an error.
This will be exposed as weak ksym support in libbpf in later patches.
--- kernel/bpf/verifier.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+)
kernel/bpf/verifier.c +18 -0
@@ -1834,6 +1834,15 @@ static int add_kfunc_call(struct bpf_verifier_env *env, u32 func_id, s16 offset) prog_aux->kfunc_tab = tab; } +/* func_id == 0 is always invalid, but instead of returning an error, be +* conservative and wait until the code elimination pass before returning +* error, so that invalid calls that get pruned out can be in BPF programs +* loaded from userspace. It is also required that offset be untouched +* for such calls. +*/ +if (!func_id && !offset) +return 0 ; +if (!btf_tab && offset) { btf_tab =kzalloc (sizeof (*btf_tab),GFP_KERNEL );if (!btf_tab)
@@ -6675,6 +6684,10 @@ static int check_kfunc_call(struct bpf_verifier_env *env, struct bpf_insn *insn)struct btf *desc_btf;int err; +/* skip for now, but return error when we find this in fixup_kfunc_call */ +if (!insn->imm) +return 0 ; + desc_btf =find_kfunc_desc_btf (env, insn->imm, insn->off, &btf_mod);if (IS_ERR (desc_btf))return PTR_ERR (desc_btf);
@@ -12810,6 +12823,11 @@ static int fixup_kfunc_call(struct bpf_verifier_env *env, {const struct bpf_kfunc_desc *desc; +if (!insn->imm) { +verbose (env,"invalid kernel function call not eliminated in verifier pass\n" ); +return -EINVAL ; + } +/* insn->imm has the btf func_id. Replace it with * an address (relative to __bpf_base_call). */
Signature · 1 line
2.33.0
Kumar Kartikeya Dwivedi
maintainerPATCH v7 3/9 bpf: btf: Introduce helpers for dynamic BTF set registration
In reply to Kumar Kartikeya DwivediThis adds helpers for registering btf_id_set from modules and the bpf_check_mod_kfunc_call callback that can be used to look them up.
With in kernel sets, the way this is supposed to work is, in kernel callback looks up within the in-kernel kfunc whitelist, and then defers to the dynamic BTF set lookup if it doesn't find the BTF id. If there is no in-kernel BTF id set, this callback can be used directly.
Also fix includes for btf.h and bpfptr.h so that they can included in isolation. This is in preparation for their usage in tcp_bbr, tcp_cubic and tcp_dctcp modules in the next patch.
--- include/linux/bpfptr.h | 1 + include/linux/btf.h | 36 +++++++++++++++++++++++++++++ kernel/bpf/btf.c | 52 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 89 insertions(+)
include/linux/bpfptr.h +1 -0
@@ -3,6 +3,7 @@#ifndef _LINUX_BPFPTR_H#define _LINUX_BPFPTR_H +#include <linux/mm.h> #include <linux/sockptr.h> typedef sockptr_t bpfptr_t ;
include/linux/btf.h +36 -0
@@ -5,6 +5,7 @@#define _LINUX_BTF_H 1#include <linux/types.h> +#include <linux/bpfptr.h> #include <uapi/linux/btf.h> #include <uapi/linux/bpf.h>
@@ -238,4 +239,39 @@ static inline const char *btf_name_by_offset(const struct btf *btf, }#endif +struct kfunc_btf_id_set { +struct list_head list; +struct btf_id_set *set; +struct module *owner; +}; + +struct kfunc_btf_id_list ; + +#ifdef CONFIG_DEBUG_INFO_BTF_MODULES +void register_kfunc_btf_id_set (struct kfunc_btf_id_list *l, +struct kfunc_btf_id_set *s); +void unregister_kfunc_btf_id_set (struct kfunc_btf_id_list *l, +struct kfunc_btf_id_set *s); +bool bpf_check_mod_kfunc_call (struct kfunc_btf_id_list *klist,u32 kfunc_id, +struct module *owner); +#else +static inline void register_kfunc_btf_id_set (struct kfunc_btf_id_list *l, +struct kfunc_btf_id_set *s) +{ +} +static inline void unregister_kfunc_btf_id_set (struct kfunc_btf_id_list *l, +struct kfunc_btf_id_set *s) +{ +} +static inline bool bpf_check_mod_kfunc_call (struct kfunc_btf_id_list *klist, +u32 kfunc_id,struct module *owner) +{ +return false; +} +#endif + +#define DEFINE_KFUNC_BTF_ID_SET (set, name) \ + struct kfunc_btf_id_set name = { LIST_HEAD_INIT(name.list), (set), \ + THIS_MODULE } +#endif
kernel/bpf/btf.c +52 -0
55 lines not on this page · raw message
Signature · 1 line
2.33.0
Kumar Kartikeya Dwivedi
maintainerPATCH v7 4/9 tools: Allow specifying base BTF file in resolve_btfids
In reply to Kumar Kartikeya DwivediThis commit allows specifying the base BTF for resolving btf id lists/sets during link time in the resolve_btfids tool. The base BTF is set to NULL if no path is passed. This allows resolving BTF ids for module kernel objects.
Also, drop the --no-fail option, as it is only used in case .BTF_ids section is not present, instead make no-fail the default mode. The long option name is same as that of pahole.
--- tools/bpf/resolve_btfids/main.c | 28 +++++++++++++++++++--------- tools/testing/selftests/bpf/Makefile | 2 +- 2 files changed, 20 insertions(+), 10 deletions(-)
tools/bpf/resolve_btfids/main.c +19 -9
@@ -89,6 +89,7 @@ struct btf_id {struct object {const char *path;const char *btf; +const char *base_btf_path;struct {int fd;
@@ -477,16 +478,27 @@ static int symbols_resolve(struct object *obj)int nr_structs = obj->nr_structs;int nr_unions = obj->nr_unions;int nr_funcs = obj->nr_funcs; +struct btf *base_btf =NULL ;int err, type_id;struct btf *btf;__u32 nr_types; - btf =btf__parse (obj->btf ?: obj->path,NULL ); +if (obj->base_btf_path) { + base_btf =btf__parse (obj->base_btf_path,NULL ); + err =libbpf_get_error (base_btf); +if (err) { +pr_err ("FAILED: load base BTF from %s: %s\n" , + obj->base_btf_path,strerror (-err)); +return -1 ; + } + } + + btf =btf__parse_split (obj->btf ?: obj->path, base_btf); err =libbpf_get_error (btf);if (err) {pr_err ("FAILED: load BTF from %s: %s\n" , obj->btf ?: obj->path,strerror (-err)); -return -1 ; + goto out; } err =-1 ;
@@ -545,6 +557,7 @@ static int symbols_resolve(struct object *obj) err =0 ; out: +btf__free (base_btf);btf__free (btf);return err; }
@@ -678,7 +691,6 @@ static const char * const resolve_btfids_usage[] = {int main (int argc,const char **argv) { -bool no_fail = false;struct object obj = { .efile = { .idlist_shndx =-1 ,
@@ -695,8 +707,8 @@ int main(int argc, const char **argv) "be more verbose (show errors, etc)"),OPT_STRING (0 ,"btf" , &obj.btf,"BTF data" ,"BTF data" ), -OPT_BOOLEAN (0 ,"no-fail" , &no_fail, -"do not fail if " BTF_IDS_SECTION " section is not found" ), +OPT_STRING ('b' ,"btf_base" , &obj.base_btf_path,"file" , +"path of file providing base BTF" ), OPT_END() };int err =-1 ;
@@ -717,10 +729,8 @@ int main(int argc, const char **argv)*/ if (obj.efile.idlist_shndx ==-1 || obj.efile.symbols_shndx ==-1 ) { -if (no_fail) -return 0 ; -pr_err ("FAILED to find needed sections\n" ); -return -1 ; +pr_debug ("Cannot find .BTF_ids or symbols sections, nothing to do\n" ); +return 0 ; }if (symbols_collect (&obj))
tools/testing/selftests/bpf/Makefile +1 -1
@@ -453,7 +453,7 @@ $(OUTPUT)/$(TRUNNER_BINARY): $(TRUNNER_TEST_OBJS) \ | $(TRUNNER_BINARY)-extras $$(call msg,BINARY,,$$@) $(Q)$$(CC) $$(CFLAGS) $$(filter %.a %.o,$$^) $$(LDLIBS) -o $$@ - $(Q)$(RESOLVE_BTFIDS) --no-fail --btf $(TRUNNER_OUTPUT)/btf_data.o $$@ + $(Q)$(RESOLVE_BTFIDS) --btf $(TRUNNER_OUTPUT)/btf_data.o $$@ endef
Signature · 1 line
2.33.0
Kumar Kartikeya Dwivedi
maintainerPATCH v7 5/9 bpf: Enable TCP congestion control kfunc from modules
In reply to Kumar Kartikeya DwivediThis commit moves BTF ID lookup into the newly added registration helper, in a way that the bbr, cubic, and dctcp implementation set up their sets in the bpf_tcp_ca kfunc_btf_set list, while the ones not dependent on modules are looked up from the wrapper function.
This lifts the restriction for them to be compiled as built in objects, and can be loaded as modules if required. Also modify Makefile.modfinal to call resolve_btfids for each module.
Note that since kernel kfunc_ids never overlap with module kfunc_ids, we only match the owner for module btf id sets.
See following commits for background on use of:
CONFIG_X86 ifdef:
569c484f9995 (bpf: Limit static tcp-cc functions in the .BTF_ids list to x86)
CONFIG_DYNAMIC_FTRACE ifdef:
7aae231ac93b (bpf: tcp: Limit calling some tcp cc functions to CONFIG_DYNAMIC_FTRACE)
--- include/linux/btf.h | 2 ++ kernel/bpf/btf.c | 2 ++ net/ipv4/bpf_tcp_ca.c | 34 +++------------------------------- net/ipv4/tcp_bbr.c | 28 +++++++++++++++++++++++++++- net/ipv4/tcp_cubic.c | 26 +++++++++++++++++++++++++- net/ipv4/tcp_dctcp.c | 26 +++++++++++++++++++++++++- scripts/Makefile.modfinal | 1 + 7 files changed, 85 insertions(+), 34 deletions(-)
include/linux/btf.h +2 -0
@@ -274,4 +274,6 @@ static inline bool bpf_check_mod_kfunc_call(struct kfunc_btf_id_list *klist,struct kfunc_btf_id_set name = {LIST_HEAD_INIT (name.list), (set), \ THIS_MODULE } +extern struct kfunc_btf_id_list bpf_tcp_ca_kfunc_list; +#endif
kernel/bpf/btf.c +2 -0
@@ -6395,3 +6395,5 @@ bool bpf_check_mod_kfunc_call(struct kfunc_btf_id_list *klist, u32 kfunc_id,struct kfunc_btf_id_list name = {LIST_HEAD_INIT (name.list), \__MUTEX_INITIALIZER (name.mutex) }; \EXPORT_SYMBOL_GPL (name) + +DEFINE_KFUNC_BTF_ID_LIST (bpf_tcp_ca_kfunc_list);
net/ipv4/bpf_tcp_ca.c +3 -31
@@ -223,41 +223,13 @@ BTF_ID(func, tcp_reno_cong_avoid) BTF_ID(func, tcp_reno_undo_cwnd) BTF_ID(func, tcp_slow_start) BTF_ID(func, tcp_cong_avoid_ai) -#ifdef CONFIG_X86 -#ifdef CONFIG_DYNAMIC_FTRACE -#if IS_BUILTIN (CONFIG_TCP_CONG_CUBIC ) -BTF_ID(func, cubictcp_init) -BTF_ID(func, cubictcp_recalc_ssthresh) -BTF_ID(func, cubictcp_cong_avoid) -BTF_ID(func, cubictcp_state) -BTF_ID(func, cubictcp_cwnd_event) -BTF_ID(func, cubictcp_acked) -#endif -#if IS_BUILTIN (CONFIG_TCP_CONG_DCTCP ) -BTF_ID(func, dctcp_init) -BTF_ID(func, dctcp_update_alpha) -BTF_ID(func, dctcp_cwnd_event) -BTF_ID(func, dctcp_ssthresh) -BTF_ID(func, dctcp_cwnd_undo) -BTF_ID(func, dctcp_state) -#endif -#if IS_BUILTIN (CONFIG_TCP_CONG_BBR ) -BTF_ID(func, bbr_init) -BTF_ID(func, bbr_main) -BTF_ID(func, bbr_sndbuf_expand) -BTF_ID(func, bbr_undo_cwnd) -BTF_ID(func, bbr_cwnd_event) -BTF_ID(func, bbr_ssthresh) -BTF_ID(func, bbr_min_tso_segs) -BTF_ID(func, bbr_set_state) -#endif -#endif /* CONFIG_DYNAMIC_FTRACE */ -#endif /* CONFIG_X86 */ BTF_SET_END (bpf_tcp_ca_kfunc_ids) static bool bpf_tcp_ca_check_kfunc_call(u32 kfunc_btf_id, struct module *owner) { -return btf_id_set_contains (&bpf_tcp_ca_kfunc_ids, kfunc_btf_id); +if (btf_id_set_contains (&bpf_tcp_ca_kfunc_ids, kfunc_btf_id)) +return true; +return bpf_check_mod_kfunc_call (&bpf_tcp_ca_kfunc_list, kfunc_btf_id, owner); }static const struct bpf_verifier_ops bpf_tcp_ca_verifier_ops = {
net/ipv4/tcp_bbr.c +27 -1
@@ -56,6 +56,8 @@* otherwise TCP stack falls back to an internal pacing using one high * resolution timer per TCP socket and may use more resources. */ +#include <linux/btf.h> +#include <linux/btf_ids.h> #include <linux/module.h> #include <net/tcp.h> #include <linux/inet_diag.h>
@@ -1152,14 +1154,38 @@ static struct tcp_congestion_ops tcp_bbr_cong_ops __read_mostly = { .set_state = bbr_set_state, }; +BTF_SET_START(tcp_bbr_kfunc_ids) +#ifdef CONFIG_X86 +#ifdef CONFIG_DYNAMIC_FTRACE +BTF_ID(func, bbr_init) +BTF_ID(func, bbr_main) +BTF_ID(func, bbr_sndbuf_expand) +BTF_ID(func, bbr_undo_cwnd) +BTF_ID(func, bbr_cwnd_event) +BTF_ID(func, bbr_ssthresh) +BTF_ID(func, bbr_min_tso_segs) +BTF_ID(func, bbr_set_state) +#endif +#endif +BTF_SET_END (tcp_bbr_kfunc_ids) + +static DEFINE_KFUNC_BTF_ID_SET(&tcp_bbr_kfunc_ids, tcp_bbr_kfunc_btf_set); +static int __init bbr_register (void ) { +int ret; +BUILD_BUG_ON (sizeof (struct bbr ) >ICSK_CA_PRIV_SIZE ); -return tcp_register_congestion_control (&tcp_bbr_cong_ops); + ret =tcp_register_congestion_control (&tcp_bbr_cong_ops); +if (ret) +return ret; +register_kfunc_btf_id_set (&bpf_tcp_ca_kfunc_list, &tcp_bbr_kfunc_btf_set); +return 0 ; } static void __exit bbr_unregister(void) { +unregister_kfunc_btf_id_set (&bpf_tcp_ca_kfunc_list, &tcp_bbr_kfunc_btf_set);tcp_unregister_congestion_control (&tcp_bbr_cong_ops); }
net/ipv4/tcp_cubic.c +25 -1
@@ -25,6 +25,8 @@*/ #include <linux/mm.h> +#include <linux/btf.h> +#include <linux/btf_ids.h> #include <linux/module.h> #include <linux/math64.h> #include <net/tcp.h>
@@ -482,8 +484,25 @@ static struct tcp_congestion_ops cubictcp __read_mostly = { .name = "cubic", }; +BTF_SET_START(tcp_cubic_kfunc_ids) +#ifdef CONFIG_X86 +#ifdef CONFIG_DYNAMIC_FTRACE +BTF_ID(func, cubictcp_init) +BTF_ID(func, cubictcp_recalc_ssthresh) +BTF_ID(func, cubictcp_cong_avoid) +BTF_ID(func, cubictcp_state) +BTF_ID(func, cubictcp_cwnd_event) +BTF_ID(func, cubictcp_acked) +#endif +#endif +BTF_SET_END (tcp_cubic_kfunc_ids) + +static DEFINE_KFUNC_BTF_ID_SET(&tcp_cubic_kfunc_ids, tcp_cubic_kfunc_btf_set); +static int __init cubictcp_register (void ) { +int ret; +BUILD_BUG_ON (sizeof (struct bictcp ) >ICSK_CA_PRIV_SIZE );/* Precompute a bunch of the scaling factors that are used per-packet
@@ -514,11 +533,16 @@ static int __init cubictcp_register(void)/* divide by bic_scale and by constant Srtt (100ms) */ do_div (cube_factor, bic_scale *10 ); -return tcp_register_congestion_control (&cubictcp); + ret =tcp_register_congestion_control (&cubictcp); +if (ret) +return ret; +register_kfunc_btf_id_set (&bpf_tcp_ca_kfunc_list, &tcp_cubic_kfunc_btf_set); +return 0 ; } static void __exit cubictcp_unregister(void) { +unregister_kfunc_btf_id_set (&bpf_tcp_ca_kfunc_list, &tcp_cubic_kfunc_btf_set);tcp_unregister_congestion_control (&cubictcp); }
net/ipv4/tcp_dctcp.c +25 -1
@@ -36,6 +36,8 @@* Glenn Judd <[email protected]> */ +#include <linux/btf.h> +#include <linux/btf_ids.h> #include <linux/module.h> #include <linux/mm.h> #include <net/tcp.h>
@@ -236,14 +238,36 @@ static struct tcp_congestion_ops dctcp_reno __read_mostly = { .name = "dctcp-reno", }; +BTF_SET_START(tcp_dctcp_kfunc_ids) +#ifdef CONFIG_X86 +#ifdef CONFIG_DYNAMIC_FTRACE +BTF_ID(func, dctcp_init) +BTF_ID(func, dctcp_update_alpha) +BTF_ID(func, dctcp_cwnd_event) +BTF_ID(func, dctcp_ssthresh) +BTF_ID(func, dctcp_cwnd_undo) +BTF_ID(func, dctcp_state) +#endif +#endif +BTF_SET_END (tcp_dctcp_kfunc_ids) + +static DEFINE_KFUNC_BTF_ID_SET(&tcp_dctcp_kfunc_ids, tcp_dctcp_kfunc_btf_set); +static int __init dctcp_register (void ) { +int ret; +BUILD_BUG_ON (sizeof (struct dctcp ) >ICSK_CA_PRIV_SIZE ); -return tcp_register_congestion_control (&dctcp); + ret =tcp_register_congestion_control (&dctcp); +if (ret) +return ret; +register_kfunc_btf_id_set (&bpf_tcp_ca_kfunc_list, &tcp_dctcp_kfunc_btf_set); +return 0 ; } static void __exit dctcp_unregister(void) { +unregister_kfunc_btf_id_set (&bpf_tcp_ca_kfunc_list, &tcp_dctcp_kfunc_btf_set);tcp_unregister_congestion_control (&dctcp); }
scripts/Makefile.modfinal +1 -0
@@ -41,6 +41,7 @@ quiet_cmd_btf_ko = BTF [M] $@ cmd_btf_ko = \ if [ -f vmlinux ]; then \ LLVM_OBJCOPY="$(OBJCOPY)" $(PAHOLE) -J --btf_base vmlinux $@; \ + $(RESOLVE_BTFIDS) -b vmlinux $@; \ else \ printf "Skipping BTF generation for %s due to unavailability of vmlinux\n" $@ 1>&2; \ fi;
Signature · 1 line
2.33.0
Kumar Kartikeya Dwivedi
maintainerPATCH v7 6/9 libbpf: Support kernel module function calls
In reply to Kumar Kartikeya DwivediThis patch adds libbpf support for kernel module function call support. The fd_array parameter is used during BPF program load to pass module BTFs referenced by the program. insn->off is set to index into this array, but starts from 1, because insn->off as 0 is reserved for btf_vmlinux.
We try to use existing insn->off for a module, since the kernel limits the maximum distinct module BTFs for kfuncs to 256, and also because index must never exceed the maximum allowed value that can fit in insn->off (INT16_MAX). In the future, if kernel interprets signed offset as unsigned for kfunc calls, this limit can be increased to UINT16_MAX.
Also introduce a btf__find_by_name_kind_own helper to start searching from module BTF's start id when we know that the BTF ID is not present in vmlinux BTF (in find_ksym_btf_id).
--- tools/lib/bpf/bpf.c | 1 + tools/lib/bpf/btf.c | 18 ++++++-- tools/lib/bpf/libbpf.c | 74 +++++++++++++++++++++++---------- tools/lib/bpf/libbpf_internal.h | 3 ++ 4 files changed, 72 insertions(+), 24 deletions(-)
tools/lib/bpf/bpf.c +1 -0
@@ -264,6 +264,7 @@ int libbpf__bpf_prog_load(const struct bpf_prog_load_params *load_attr) attr.line_info_rec_size = load_attr->line_info_rec_size; attr.line_info_cnt = load_attr->line_info_cnt; attr.line_info =ptr_to_u64 (load_attr->line_info); + attr.fd_array =ptr_to_u64 (load_attr->fd_array);if (load_attr->name) memcpy(attr.prog_name, load_attr->name,
tools/lib/bpf/btf.c +15 -3
@@ -695,15 +695,15 @@ __s32 btf__find_by_name(const struct btf *btf, const char *type_name)return libbpf_err (-ENOENT ); } -__s32 btf__find_by_name_kind (const struct btf *btf,const char *type_name, -__u32 kind) +static __s32 btf_find_by_name_kind (const struct btf *btf,int start_id, +const char *type_name,__u32 kind) {__u32 i, nr_types =btf__get_nr_types (btf);if (kind ==BTF_KIND_UNKN || !strcmp (type_name,"void" ))return 0 ; -for (i =1 ; i <= nr_types; i++) { +for (i = start_id; i <= nr_types; i++) {const struct btf_type *t =btf__type_by_id (btf, i);const char *name;
@@ -717,6 +717,18 @@ __s32 btf__find_by_name_kind(const struct btf *btf, const char *type_name,return libbpf_err (-ENOENT ); } +__s32 btf__find_by_name_kind_own (const struct btf *btf,const char *type_name, +__u32 kind) +{ +return btf_find_by_name_kind (btf, btf->start_id, type_name, kind); +} + +__s32 btf__find_by_name_kind (const struct btf *btf,const char *type_name, +__u32 kind) +{ +return btf_find_by_name_kind (btf,1 , type_name, kind); +} +static bool btf_is_modifiable (const struct btf *btf) {return (void *)btf->hdr != btf->raw_data;
tools/lib/bpf/libbpf.c +53 -21
172 lines not on this page · raw message
tools/lib/bpf/libbpf_internal.h +3 -0
@@ -298,6 +298,7 @@ struct bpf_prog_load_params {__u32 log_level;char *log_buf;size_t log_buf_sz; +int *fd_array; };int libbpf__bpf_prog_load (const struct bpf_prog_load_params *load_attr);
@@ -408,6 +409,8 @@ int btf_type_visit_type_ids(struct btf_type *t, type_id_visit_fn visit, void *ctint btf_type_visit_str_offs (struct btf_type *t,str_off_visit_fn visit,void *ctx);int btf_ext_visit_type_ids (struct btf_ext *btf_ext,type_id_visit_fn visit,void *ctx);int btf_ext_visit_str_offs (struct btf_ext *btf_ext,str_off_visit_fn visit,void *ctx); +__s32 btf__find_by_name_kind_own (const struct btf *btf,const char *type_name, +__u32 kind);extern enum libbpf_strict_mode libbpf_mode;
Signature · 1 line
2.33.0
Kumar Kartikeya Dwivedi
maintainerPATCH v7 7/9 libbpf: Resolve invalid weak kfunc calls with imm = 0, off = 0
In reply to Kumar Kartikeya DwivediPreserve these calls as it allows verifier to succeed in loading the program if they are determined to be unreachable after dead code elimination during program load. If not, the verifier will fail at runtime. This is done for ext->is_weak symbols similar to the case for variable ksyms.
--- tools/lib/bpf/libbpf.c | 24 +++++++++++++----------- 1 file changed, 13 insertions(+), 11 deletions(-)
tools/lib/bpf/libbpf.c +13 -11
@@ -3439,11 +3439,6 @@ static int bpf_object__collect_externs(struct bpf_object *obj)return -ENOTSUP ; } }else if (strcmp (sec_name,KSYMS_SEC ) ==0 ) { -if (btf_is_func (t) && ext->is_weak) { -pr_warn ("extern weak function %s is unsupported\n" , - ext->name); -return -ENOTSUP ; - } ksym_sec = sec; ext->type =EXT_KSYM ; skip_mods_and_typedefs(obj->btf, t->type,
@@ -5416,8 +5411,13 @@ bpf_object__relocate_data(struct bpf_object *obj, struct bpf_program *prog)case RELO_EXTERN_FUNC : ext = &obj->externs[relo->sym_off]; insn[0 ].src_reg =BPF_PSEUDO_KFUNC_CALL ; - insn[0 ].imm = ext->ksym.kernel_btf_id; - insn[0 ].off = ext->ksym.btf_fd_idx; +if (ext->is_set) { + insn[0 ].imm = ext->ksym.kernel_btf_id; + insn[0 ].off = ext->ksym.btf_fd_idx; + }else {/* unresolved weak kfunc */ + insn[0 ].imm =0 ; + insn[0 ].off =0 ; + }break ;case RELO_SUBPROG_ADDR :if (insn[0 ].src_reg !=BPF_PSEUDO_FUNC ) {
@@ -6807,9 +6807,9 @@ static int bpf_object__resolve_ksym_var_btf_id(struct bpf_object *obj,int id, err; id =find_ksym_btf_id (obj, ext->name,BTF_KIND_VAR , &btf, &mod_btf); -if (id == -ESRCH && ext->is_weak) { -return 0 ; - }else if (id <0 ) { +if (id <0 ) { +if (id == -ESRCH && ext->is_weak) +return 0 ;pr_warn ("extern (var ksym) '%s': not found in kernel BTF\n" , ext->name);return id;
@@ -6862,7 +6862,9 @@ static int bpf_object__resolve_ksym_func_btf_id(struct bpf_object *obj, kfunc_id =find_ksym_btf_id (obj, ext->name,BTF_KIND_FUNC , &kern_btf, &mod_btf);if (kfunc_id <0 ) { -pr_warn ("extern (func ksym) '%s': not found in kernel BTF\n" , +if (kfunc_id == -ESRCH && ext->is_weak) +return 0 ; +pr_warn ("extern (func ksym) '%s': not found in kernel or module BTFs\n" , ext->name);return kfunc_id; }
Signature · 1 line
2.33.0
Kumar Kartikeya Dwivedi
maintainerPATCH v7 8/9 libbpf: Update gen_loader to emit BTF_KIND_FUNC relocations
In reply to Kumar Kartikeya DwivediThis change updates the BPF syscall loader to relocate BTF_KIND_FUNC relocations, with support for weak kfunc relocations. The general idea is to move map_fds to loader map, and also use the data for storing kfunc BTF fds. Since both reuse the fd_array parameter, they need to be kept together.
For map_fds, we reserve MAX_USED_MAPS slots in a region, and for kfunc, we reserve MAX_KFUNC_DESCS. This is done so that insn->off has more chances of being <= INT16_MAX than treating data map as a sparse array and adding fd as needed.
When the MAX_KFUNC_DESCS limit is reached, we fall back to the sparse array model, so that as long as it does remain <= INT16_MAX, we pass an index relative to the start of fd_array.
We store all ksyms in an array where we try to avoid calling the bpf_btf_find_by_name_kind helper, and also reuse the BTF fd that was already stored. This also speeds up the loading process compared to emitting calls in all cases, in later tests.
--- tools/lib/bpf/bpf_gen_internal.h | 16 +- tools/lib/bpf/gen_loader.c | 314 +++++++++++++++++++++++++------ tools/lib/bpf/libbpf.c | 8 +- 3 files changed, 280 insertions(+), 58 deletions(-)
tools/lib/bpf/bpf_gen_internal.h +15 -1
@@ -7,6 +7,15 @@ struct ksym_relo_desc {const char *name;int kind;int insn_idx; +bool is_weak; +}; + +struct ksym_desc { +const char *name; +int ref; +int kind; +int off; +int insn; };struct bpf_gen {
@@ -24,6 +33,10 @@ struct bpf_gen {int relo_cnt;char attach_target[128 ];int attach_kind; +struct ksym_desc *ksyms; +__u32 nr_ksyms; +int fd_array; +int nr_fd_array; };void bpf_gen__init (struct bpf_gen *gen,int log_level);
@@ -36,6 +49,7 @@ void bpf_gen__prog_load(struct bpf_gen *gen, struct bpf_prog_load_params *load_avoid bpf_gen__map_update_elem (struct bpf_gen *gen,int map_idx,void *value,__u32 value_size);void bpf_gen__map_freeze (struct bpf_gen *gen,int map_idx);void bpf_gen__record_attach_target (struct bpf_gen *gen,const char *name,enum bpf_attach_type type); -void bpf_gen__record_extern (struct bpf_gen *gen,const char *name,int kind,int insn_idx); +void bpf_gen__record_extern (struct bpf_gen *gen,const char *name,bool is_weak,int kind, +int insn_idx);#endif
tools/lib/bpf/gen_loader.c +261 -53
415 lines not on this page · raw message
tools/lib/bpf/libbpf.c +4 -4
@@ -6360,12 +6360,12 @@ static int bpf_program__record_externs(struct bpf_program *prog) ext->name);return -ENOTSUP ; } -bpf_gen__record_extern (obj->gen_loader, ext->name,BTF_KIND_VAR , - relo->insn_idx); +bpf_gen__record_extern (obj->gen_loader, ext->name, ext->is_weak, +BTF_KIND_VAR , relo->insn_idx);break ;case RELO_EXTERN_FUNC : -bpf_gen__record_extern (obj->gen_loader, ext->name,BTF_KIND_FUNC , - relo->insn_idx); +bpf_gen__record_extern (obj->gen_loader, ext->name, ext->is_weak, +BTF_KIND_FUNC , relo->insn_idx);break ;default :continue ;
Signature · 1 line
2.33.0
Kumar Kartikeya Dwivedi
maintainerPATCH v7 9/9 bpf: selftests: Add selftests for module kfunc support
In reply to Kumar Kartikeya DwivediThis adds selftests that tests the success and failure path for modules kfuncs (in presence of invalid kfunc calls) for both libbpf and gen_loader. It also adds a prog_test kfunc_btf_id_list so that we can add module BTF ID set from bpf_testmod.
This also introduces a couple of test cases to verifier selftests for validating whether we get an error or not depending on if invalid kfunc call remains after elimination of unreachable instructions.
--- include/linux/btf.h | 1 + kernel/bpf/btf.c | 1 + net/bpf/test_run.c | 5 +- tools/testing/selftests/bpf/Makefile | 7 +-- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 23 +++++++++- .../selftests/bpf/prog_tests/ksyms_module.c | 29 ++++++------ .../bpf/prog_tests/ksyms_module_libbpf.c | 28 +++++++++++ .../selftests/bpf/progs/test_ksyms_module.c | 46 ++++++++++++++----- tools/testing/selftests/bpf/verifier/calls.c | 23 ++++++++++ 9 files changed, 132 insertions(+), 31 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/ksyms_module_libbpf.c
include/linux/btf.h +1 -0
@@ -275,5 +275,6 @@ static inline bool bpf_check_mod_kfunc_call(struct kfunc_btf_id_list *klist, THIS_MODULE } extern struct kfunc_btf_id_list bpf_tcp_ca_kfunc_list; +extern struct kfunc_btf_id_list prog_test_kfunc_list;#endif
kernel/bpf/btf.c +1 -0
@@ -6397,3 +6397,4 @@ bool bpf_check_mod_kfunc_call(struct kfunc_btf_id_list *klist, u32 kfunc_id,EXPORT_SYMBOL_GPL (name)DEFINE_KFUNC_BTF_ID_LIST (bpf_tcp_ca_kfunc_list); +DEFINE_KFUNC_BTF_ID_LIST (prog_test_kfunc_list);
net/bpf/test_run.c +4 -1
@@ -2,6 +2,7 @@/* Copyright (c) 2017 Facebook */ #include <linux/bpf.h> +#include <linux/btf.h> #include <linux/btf_ids.h> #include <linux/slab.h> #include <linux/vmalloc.h>
@@ -243,7 +244,9 @@ BTF_SET_END(test_sk_kfunc_ids)bool bpf_prog_test_check_kfunc_call (u32 kfunc_id,struct module *owner) { -return btf_id_set_contains (&test_sk_kfunc_ids, kfunc_id); +if (btf_id_set_contains (&test_sk_kfunc_ids, kfunc_id)) +return true; +return bpf_check_mod_kfunc_call (&prog_test_kfunc_list, kfunc_id, owner); } static void *bpf_test_init(const union bpf_attr *kattr, u32 size,
tools/testing/selftests/bpf/Makefile +4 -3
@@ -315,8 +315,9 @@ LINKED_SKELS := test_static_linked.skel.h linked_funcs.skel.h \ linked_vars.skel.h linked_maps.skel.h LSKELS := kfunc_call_test.c fentry_test.c fexit_test.c fexit_sleep.c \ - test_ksyms_module.c test_ringbuf.c atomics.c trace_printk.c \ - trace_vprintk.c + test_ringbuf.c atomics.c trace_printk.c trace_vprintk.c +# Generate both light skeleton and libbpf skeleton for these +LSKELS_EXTRA := test_ksyms_module.c SKEL_BLACKLIST += $$(LSKELS) test_static_linked.skel.h-deps := test_static_linked1.o test_static_linked2.o
@@ -346,7 +347,7 @@ TRUNNER_BPF_OBJS := $$(patsubst %.c,$$(TRUNNER_OUTPUT)/%.o, $$(TRUNNER_BPF_SRCS) TRUNNER_BPF_SKELS := $$(patsubst %.c,$$(TRUNNER_OUTPUT)/%.skel.h, \ $$(filter-out $(SKEL_BLACKLIST) $(LINKED_BPF_SRCS),\ $$(TRUNNER_BPF_SRCS))) -TRUNNER_BPF_LSKELS := $$(patsubst %.c,$$(TRUNNER_OUTPUT)/%.lskel.h, $$(LSKELS)) +TRUNNER_BPF_LSKELS := $$(patsubst %.c,$$(TRUNNER_OUTPUT)/%.lskel.h, $$(LSKELS) $$(LSKELS_EXTRA)) TRUNNER_BPF_SKELS_LINKED := $$(addprefix $$(TRUNNER_OUTPUT)/,$(LINKED_SKELS)) TEST_GEN_FILES += $$(TRUNNER_BPF_OBJS)
tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c +22 -1
@@ -1,5 +1,7 @@// SPDX-License-Identifier: GPL-2.0 /* Copyright (c) 2020 Facebook */ +#include <linux/btf.h> +#include <linux/btf_ids.h> #include <linux/error-injection.h> #include <linux/init.h> #include <linux/module.h>
@@ -13,6 +15,12 @@DEFINE_PER_CPU (int, bpf_testmod_ksym_percpu) =123 ; +noinline void +bpf_testmod_test_mod_kfunc (int i) +{ + *(int *)this_cpu_ptr (&bpf_testmod_ksym_percpu) = i; +} + noinline int bpf_testmod_loop_test(int n) {int i, sum =0 ;
@@ -71,13 +79,26 @@ static struct bin_attribute bin_attr_bpf_testmod_file __ro_after_init = { .write = bpf_testmod_test_write, }; +BTF_SET_START(bpf_testmod_kfunc_ids) +BTF_ID(func, bpf_testmod_test_mod_kfunc) +BTF_SET_END(bpf_testmod_kfunc_ids) + +static DEFINE_KFUNC_BTF_ID_SET(&bpf_testmod_kfunc_ids, bpf_testmod_kfunc_btf_set); +static int bpf_testmod_init (void ) { -return sysfs_create_bin_file (kernel_kobj, &bin_attr_bpf_testmod_file); +int ret; + + ret =sysfs_create_bin_file (kernel_kobj, &bin_attr_bpf_testmod_file); +if (ret) +return ret; +register_kfunc_btf_id_set (&prog_test_kfunc_list, &bpf_testmod_kfunc_btf_set); +return 0 ; }static void bpf_testmod_exit (void ) { +unregister_kfunc_btf_id_set (&prog_test_kfunc_list, &bpf_testmod_kfunc_btf_set);return sysfs_remove_bin_file (kernel_kobj, &bin_attr_bpf_testmod_file); }
tools/testing/selftests/bpf/prog_tests/ksyms_module.c +14 -15
@@ -2,30 +2,29 @@/* Copyright (c) 2021 Facebook */ #include <test_progs.h> -#include <bpf/libbpf.h> -#include <bpf/btf.h> +#include <network_helpers.h> #include "test_ksyms_module.lskel.h" -static int duration; -void test_ksyms_module (void ) { -struct test_ksyms_module * skel; +struct test_ksyms_module *skel; +int retval;int err; - skel =test_ksyms_module__open_and_load (); -if (CHECK (!skel,"skel_open" ,"failed to open skeleton\n" )) +if (!env.has_testmod) { +test__skip ();return ; + } - err =test_ksyms_module__attach (skel); -if (CHECK (err,"skel_attach" ,"skeleton attach failed: %d\n" , err)) + skel =test_ksyms_module__open_and_load (); +if (!ASSERT_OK_PTR (skel,"test_ksyms_module__open_and_load" )) +return ; + err =bpf_prog_test_run (skel->progs.load.prog_fd,1 , &pkt_v4,sizeof (pkt_v4), +NULL ,NULL , (__u32 *)&retval,NULL ); +if (!ASSERT_OK (err,"bpf_prog_test_run" )) goto cleanup; - -usleep (1 ); - -ASSERT_EQ (skel->bss->triggered, true,"triggered" ); -ASSERT_EQ (skel->bss->out_mod_ksym_global,123 ,"global_ksym_val" ); - +ASSERT_EQ (retval,0 ,"retval" ); +ASSERT_EQ (skel->bss->out_bpf_testmod_ksym,42 ,"bpf_testmod_ksym" ); cleanup:test_ksyms_module__destroy (skel); }
tools/testing/selftests/bpf/prog_tests/ksyms_module_libbpf.c new file +28 -0
@@ -0,0 +1,28 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <test_progs.h> +#include <network_helpers.h> +#include "test_ksyms_module.skel.h" + +void test_ksyms_module_libbpf (void ) +{ +struct test_ksyms_module *skel; +int retval, err; + +if (!env.has_testmod) { +test__skip (); +return ; + } + + skel =test_ksyms_module__open_and_load (); +if (!ASSERT_OK_PTR (skel,"test_ksyms_module__open" )) +return ; + err =bpf_prog_test_run (bpf_program__fd (skel->progs.load),1 , &pkt_v4, +sizeof (pkt_v4),NULL ,NULL , (__u32 *)&retval,NULL ); +if (!ASSERT_OK (err,"bpf_prog_test_run" )) + goto cleanup; +ASSERT_EQ (retval,0 ,"retval" ); +ASSERT_EQ (skel->bss->out_bpf_testmod_ksym,42 ,"bpf_testmod_ksym" ); +cleanup: +test_ksyms_module__destroy (skel); +}
tools/testing/selftests/bpf/progs/test_ksyms_module.c +35 -11
59 lines not on this page · raw message
tools/testing/selftests/bpf/verifier/calls.c +23 -0
@@ -1,3 +1,26 @@ +{ + "calls: invalid kfunc call not eliminated", + .insns = { +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,BPF_PSEUDO_KFUNC_CALL ,0 ,0 ), +BPF_MOV64_IMM (BPF_REG_0 ,1 ), + BPF_EXIT_INSN(), + }, + .prog_type =BPF_PROG_TYPE_TRACEPOINT , + .result = REJECT, + .errstr = "invalid kernel function call not eliminated in verifier pass", +}, +{ +"calls: invalid kfunc call unreachable" , + .insns = { +BPF_MOV64_IMM (BPF_REG_0 ,1 ), +BPF_JMP_IMM (BPF_JGT ,BPF_REG_0 ,0 ,2 ), +BPF_RAW_INSN (BPF_JMP |BPF_CALL ,0 ,BPF_PSEUDO_KFUNC_CALL ,0 ,0 ), +BPF_MOV64_IMM (BPF_REG_0 ,1 ), + BPF_EXIT_INSN(), + }, + .prog_type =BPF_PROG_TYPE_TRACEPOINT , + .result = ACCEPT, +}, {"calls: basic sanity" , .insns = {
Signature · 1 line
2.33.0
Quoted 17 lines · Kumar Kartikeya Dwivedi
This set enables kernel module function calls, and also modifies verifier logic to permit invalid kernel function calls as long as they are pruned as part of dead code elimination. This is done to provide better runtime portability for BPF objects, which can conditionally disable parts of code that are pruned later by the verifier (e.g. const volatile vars, kconfig options). libbpf modifications are made along with kernel changes to support module function calls.
It also converts TCP congestion control objects to use the module kfunc support instead of relying on
IS_BUILTINifdef.Changelog:
----------
v6 -> v7
v6: https://lore.kernel.org/bpf/[email protected]
Quoted 9 lines
* Let
__bpf_check_kfunc_calltakekfunc_btf_id_listinstead of generating callbacks (Andrii)
* Rename it tobpf_check_mod_kfunc_callto reflect usage
* Remove OOM checks (Alexei)
* Removeresolve_btfidsinvocation forbpf_testmod(Andrii)
* Movefd_array_cntinitialization nearfd_arrayalloc (Andrii)
* Rename helper tobtf_find_by_name_kindand passstart_id(Andrii)
* memset when data is NULL inadd_data(Alexei)
* Fix other nits
Looking good now. Applied. Thanks