Support kernel module ksym variables
Subsystems (8)
Andrii Nakryiko
maintainerv2 cover Support kernel module ksym variables
Add support for using kernel module global variables (__ksym externs in BPF program). BPF verifier will now support ldimm64 with src_reg=BPF_PSEUDO_BTF_ID and non-zero insn[1].imm field, specifying module BTF's FD. In such case, module BTF object, similarly to BPF maps referenced from ldimm64 with src_reg=BPF_PSEUDO_MAP_FD, will be recorded in bpf_progran's auxiliary data and refcnt will be increased for both BTF object itself and its kernel module. This makes sure kernel module won't be unloaded from under active attached BPF program. These refcounts will be dropped when BPF program is unloaded.
New selftest validates all this is working as intended. bpf_testmod.ko is extended with per-CPU variable. Selftests expects the latest pahole changes (soon to be released as v1.20) to generate per-CPU variable BTF info for kernel module.
v1->v2:
- fixed few compiler warnings, posted as separate pre-patches;rfc->v1:
- use sys_membarrier(MEMBARRIER_CMD_GLOBAL) (Alexei).
Cc: Hao Luo <[email protected]>
Andrii Nakryiko (7):
bpf: add bpf_patch_call_args prototype to include/linux/bpf.h
bpf: avoid warning when re-casting __bpf_call_base into
__bpf_call_base_args
bpf: declare __bpf_free_used_maps() unconditionally selftests/bpf: sync RCU before unloading bpf_testmod
bpf: support BPF ksym variables in kernel modules
libbpf: support kernel module ksym externs selftests/bpf: test kernel module ksym externs
include/linux/bpf.h | 18 ++- include/linux/bpf_verifier.h | 3 + include/linux/btf.h | 3 + include/linux/filter.h | 2 +- kernel/bpf/btf.c | 31 +++- kernel/bpf/core.c | 23 +++ kernel/bpf/verifier.c | 149 ++++++++++++++---- tools/lib/bpf/libbpf.c | 47 ++++-- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 3 + .../selftests/bpf/prog_tests/btf_map_in_map.c | 33 ---- .../selftests/bpf/prog_tests/ksyms_module.c | 33 ++++ .../selftests/bpf/progs/test_ksyms_module.c | 26 +++ tools/testing/selftests/bpf/test_progs.c | 11 ++ tools/testing/selftests/bpf/test_progs.h | 1 + 14 files changed, 300 insertions(+), 83 deletions(-) create mode 100644 tools/testing/selftests/bpf/prog_tests/ksyms_module.c create mode 100644 tools/testing/selftests/bpf/progs/test_ksyms_module.c
Signature · 1 line
2.24.1
Andrii Nakryiko
maintainerPATCH v2 1/7 bpf: add bpf_patch_call_args prototype to include/linux/bpf.h
Add bpf_patch_call_args() prototype. This function is called from BPF verifier and only if CONFIG_BPF_JIT_ALWAYS_ON is not defined. This fixes compiler warning about missing prototype in some kernel configurations.
--- include/linux/bpf.h | 3 +++ 1 file changed, 3 insertions(+)
include/linux/bpf.h +3 -0
@@ -1403,7 +1403,10 @@ static inline void bpf_long_memcpy(void *dst, const void *src, u32 size)/* verify correctness of eBPF program */ int bpf_check (struct bpf_prog **fp,union bpf_attr *attr,union bpf_attr __user *uattr); + +#ifndef CONFIG_BPF_JIT_ALWAYS_ON void bpf_patch_call_args (struct bpf_insn *insn,u32 stack_depth); +#endif struct btf *bpf_get_btf_vmlinux (void );
Signature · 1 line
2.24.1
Re: [PATCH v2 bpf-next 1/7] bpf: add bpf_patch_call_args prototype to include/linux/bpf.h
Quoted 7 lines · Andrii Nakryiko
Add
bpf_patch_call_args()prototype. This function is called from BPF verifier and only ifCONFIG_BPF_JIT_ALWAYS_ONis not defined. This fixes compiler warning about missing prototype in some kernel configurations.Reported-by kernel test robot <[email protected]>Fixes 1ea47e01ad6e ("bpf: add support for bpf_call to interpreter")Signed-off-by Andrii Nakryiko <[email protected]>
Andrii Nakryiko
maintainerPATCH v2 2/7 bpf: avoid warning when re-casting __bpf_call_base into __bpf_call_base_args
In reply to Andrii NakryikoBPF interpreter uses extra input argument, so re-casts __bpf_call_base into __bpf_call_base_args. Avoid compiler warning about incompatible function prototypes by casting to void * first.
--- include/linux/filter.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
include/linux/filter.h +1 -1
@@ -886,7 +886,7 @@ void sk_filter_uncharge(struct sock *sk, struct sk_filter *fp);u64 __bpf_call_base (u64 r1,u64 r2,u64 r3,u64 r4,u64 r5);#define __bpf_call_base_args \ ((u64 (*)(u64, u64, u64, u64, u64, const struct bpf_insn *)) \ - __bpf_call_base) + (void *)__bpf_call_base)struct bpf_prog *bpf_int_jit_compile (struct bpf_prog *prog);void bpf_jit_compile (struct bpf_prog *prog);
Signature · 1 line
2.24.1
Re: [PATCH v2 bpf-next 2/7] bpf: avoid warning when re-casting __bpf_call_base into __bpf_call_base_args
Quoted 7 lines · Andrii Nakryiko
BPF interpreter uses extra input argument, so re-casts
__bpf_call_baseinto__bpf_call_base_args. Avoid compiler warning about incompatible function prototypes by casting to void * first.Reported-by kernel test robot <[email protected]>Fixes 1ea47e01ad6e ("bpf: add support for bpf_call to interpreter")Signed-off-by Andrii Nakryiko <[email protected]>
Andrii Nakryiko
maintainerPATCH v2 3/7 bpf: declare __bpf_free_used_maps() unconditionally
In reply to Andrii Nakryiko__bpf_free_used_maps() is always defined in kernel/bpf/core.c, while include/linux/bpf.h is guarding it behind CONFIG_BPF_SYSCALL. Move it out of that guard region and fix compiler warning.
--- include/linux/bpf.h | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
include/linux/bpf.h +3 -2
@@ -1206,8 +1206,6 @@ void bpf_prog_sub(struct bpf_prog *prog, int i);void bpf_prog_inc (struct bpf_prog *prog);struct bpf_prog *__must_check bpf_prog_inc_not_zero (struct bpf_prog *prog);void bpf_prog_put (struct bpf_prog *prog); -void __bpf_free_used_maps (struct bpf_prog_aux *aux, -struct bpf_map **used_maps,u32 len);void bpf_prog_free_id (struct bpf_prog *prog,bool do_idr_lock);void bpf_map_free_id (struct bpf_map *map,bool do_idr_lock);
@@ -1676,6 +1674,9 @@ static inline struct bpf_prog *bpf_prog_get_type(u32 ufd,return bpf_prog_get_type_dev (ufd, type, false); } +void __bpf_free_used_maps (struct bpf_prog_aux *aux, +struct bpf_map **used_maps,u32 len); +bool bpf_prog_get_ok (struct bpf_prog *,enum bpf_prog_type *,bool );int bpf_prog_offload_compile (struct bpf_prog *prog);
Signature · 1 line
2.24.1
Re: [PATCH v2 bpf-next 3/7] bpf: declare __bpf_free_used_maps() unconditionally
Quoted 7 lines · Andrii Nakryiko
__bpf_free_used_maps()is always defined inkernel/bpf/core.c, whileinclude/linux/bpf.his guarding it behindCONFIG_BPF_SYSCALL. Move it out of that guard region and fix compiler warning.Reported-by kernel test robot <[email protected]>Fixes a2ea07465c8d ("bpf: Fix missing prog untrack in release_maps")Signed-off-by Andrii Nakryiko <[email protected]>
Andrii Nakryiko
maintainerPATCH v2 4/7 selftests/bpf: sync RCU before unloading bpf_testmod
In reply to Andrii NakryikoIf some of the subtests use module BTFs through ksyms, they will cause bpf_prog to take a refcount on bpf_testmod module, which will prevent it from successfully unloading. Module's refcnt is decremented when bpf_prog is freed, which generally happens in RCU callback. So we need to trigger syncronize_rcu() in the kernel, which can be achieved nicely with membarrier(MEMBARRIER_CMD_GLOBAL) syscall. So do that in kernel_sync_rcu() and make it available to other test inside the test_progs. This synchronize_rcu() is called before attempting to unload bpf_testmod.
--- .../selftests/bpf/prog_tests/btf_map_in_map.c | 33 ------------------- tools/testing/selftests/bpf/test_progs.c | 11 +++++++ tools/testing/selftests/bpf/test_progs.h | 1 + 3 files changed, 12 insertions(+), 33 deletions(-)
tools/testing/selftests/bpf/prog_tests/btf_map_in_map.c +0 -33
@@ -20,39 +20,6 @@ static __u32 bpf_map_id(struct bpf_map *map)return info.id; } -/* -* Trigger synchronize_rcu() in kernel. -* -* ARRAY_OF_MAPS/HASH_OF_MAPS lookup/update operations trigger synchronize_rcu() -* if looking up an existing non-NULL element or updating the map with a valid -* inner map FD. Use this fact to trigger synchronize_rcu(): create map-in-map, -* create a trivial ARRAY map, update map-in-map with ARRAY inner map. Then -* cleanup. At the end, at least one synchronize_rcu() would be called. -*/ -static int kern_sync_rcu (void ) -{ -int inner_map_fd, outer_map_fd, err, zero =0 ; - - inner_map_fd =bpf_create_map (BPF_MAP_TYPE_ARRAY ,4 ,4 ,1 ,0 ); -if (CHECK (inner_map_fd <0 ,"inner_map_create" ,"failed %d\n" , -errno)) -return -1 ; - - outer_map_fd =bpf_create_map_in_map (BPF_MAP_TYPE_ARRAY_OF_MAPS ,NULL , -sizeof (int ), inner_map_fd,1 ,0 ); -if (CHECK (outer_map_fd <0 ,"outer_map_create" ,"failed %d\n" , -errno)) { -close (inner_map_fd); -return -1 ; - } - - err =bpf_map_update_elem (outer_map_fd, &zero, &inner_map_fd,0 ); -if (err) - err = -errno; -CHECK (err,"outer_map_update" ,"failed %d\n" , err); -close (inner_map_fd); -close (outer_map_fd); -return err; -} -static void test_lookup_update (void ) {int map1_fd, map2_fd, map3_fd, map4_fd, map5_fd, map1_id, map2_id;
tools/testing/selftests/bpf/test_progs.c +11 -0
@@ -11,6 +11,7 @@#include <signal.h> #include <string.h> #include <execinfo.h> /* backtrace */ +#include <linux/membarrier.h> #define EXIT_NO_TEST 2#define EXIT_ERR_SETUP_INFRA 3
@@ -370,8 +371,18 @@ static int delete_module(const char *name, int flags)return syscall (__NR_delete_module, name, flags); } +/* +* Trigger synchronize_rcu() in kernel. +*/ +int kern_sync_rcu (void ) +{ +return syscall (__NR_membarrier,MEMBARRIER_CMD_GLOBAL ,0 ,0 ); +} +static void unload_bpf_testmod (void ) { +if (kern_sync_rcu ()) +fprintf (env.stderr,"Failed to trigger kernel-side RCU sync!\n" );if (delete_module ("bpf_testmod" ,0 )) {if (errno ==ENOENT ) {if (env.verbosity >VERBOSE_NONE )
tools/testing/selftests/bpf/test_progs.h +1 -0
@@ -219,6 +219,7 @@ int bpf_find_map(const char *test, struct bpf_object *obj, const char *name);int compare_map_keys (int map1_fd,int map2_fd);int compare_stack_ips (int smap_fd,int amap_fd,int stack_trace_len);int extract_build_id (char *build_id,size_t size); +int kern_sync_rcu (void );#ifdef __x86_64__#define SYS_NANOSLEEP_KPROBE_NAME "__x64_sys_nanosleep"
Signature · 1 line
2.24.1
Re: [PATCH v2 bpf-next 4/7] selftests/bpf: sync RCU before unloading bpf_testmod
Quoted 9 lines · Andrii Nakryiko
If some of the subtests use module BTFs through ksyms, they will cause
bpf_progto take a refcount onbpf_testmodmodule, which will prevent it from successfully unloading. Module's refcnt is decremented whenbpf_progis freed, which generally happens in RCU callback. So we need to triggersyncronize_rcu()in the kernel, which can be achieved nicely withmembarrier(MEMBARRIER_CMD_GLOBAL)syscall. So do that inkernel_sync_rcu()and make it available to other test inside thetest_progs. Thissynchronize_rcu()is called before attempting to unloadbpf_testmod.
Quoted 3 lines
Fixes 9f7fa225894c ("selftests/bpf: Add bpf_testmod kernel module for testing")Suggested-by Alexei Starovoitov <[email protected]>Signed-off-by Andrii Nakryiko <[email protected]>
Hao Luo
Acked-byRe: [PATCH v2 bpf-next 4/7] selftests/bpf: sync RCU before unloading bpf_testmod
Quoted 18 lines · Yonghong Song
Quoted 9 lines · Andrii Nakryiko
If some of the subtests use module BTFs through ksyms, they will cause
bpf_progto take a refcount onbpf_testmodmodule, which will prevent it from successfully unloading. Module's refcnt is decremented whenbpf_progis freed, which generally happens in RCU callback. So we need to triggersyncronize_rcu()in the kernel, which can be achieved nicely withmembarrier(MEMBARRIER_CMD_GLOBAL)syscall. So do that inkernel_sync_rcu()and make it available to other test inside thetest_progs. Thissynchronize_rcu()is called before attempting to unloadbpf_testmod.Quoted 3 lines
Fixes 9f7fa225894c ("selftests/bpf: Add bpf_testmod kernel module for testing")Suggested-by Alexei Starovoitov <[email protected]>Signed-off-by Andrii Nakryiko <[email protected]>Acked-by Yonghong Song <[email protected]>
Andrii Nakryiko
maintainerPATCH v2 5/7 bpf: support BPF ksym variables in kernel modules
In reply to Andrii NakryikoAdd support for directly accessing kernel module variables from BPF programs using special ldimm64 instructions. This functionality builds upon vmlinux ksym support, but extends ldimm64 with src_reg=BPF_PSEUDO_BTF_ID to allow specifying kernel module BTF's FD in insn[1].imm field.
During BPF program load time, verifier will resolve FD to BTF object and will take reference on BTF object itself and, for module BTFs, corresponding module as well, to make sure it won't be unloaded from under running BPF program. The mechanism used is similar to how bpf_prog keeps track of used bpf_maps.
One interesting change is also in how per-CPU variable is determined. The logic is to find .data..percpu data section in provided BTF, but both vmlinux and module each have their own .data..percpu entries in BTF. So for module's case, the search for DATASEC record needs to look at only module's added BTF types. This is implemented with custom search function.
--- include/linux/bpf.h | 10 +++ include/linux/bpf_verifier.h | 3 + include/linux/btf.h | 3 + kernel/bpf/btf.c | 31 +++++++- kernel/bpf/core.c | 23 ++++++ kernel/bpf/verifier.c | 149 ++++++++++++++++++++++++++++------- 6 files changed, 189 insertions(+), 30 deletions(-)
include/linux/bpf.h +10 -0
@@ -761,9 +761,15 @@ struct bpf_ctx_arg_aux {u32 btf_id; }; +struct btf_mod_pair { +struct btf *btf; +struct module *module; +}; +struct bpf_prog_aux {atomic64_t refcnt;u32 used_map_cnt; +u32 used_btf_cnt;u32 max_ctx_offset;u32 max_pkt_offset;u32 max_tp_access;
@@ -802,6 +808,7 @@ struct bpf_prog_aux {const struct bpf_prog_ops *ops;struct bpf_map **used_maps;struct mutex used_maps_mutex;/* mutex for used_maps and used_map_cnt */ +struct btf_mod_pair *used_btfs;struct bpf_prog *prog;struct user_struct *user;u64 load_time;/* ns since boottime */
@@ -1668,6 +1675,9 @@ bpf_base_func_proto(enum bpf_func_id func_id) }#endif /* CONFIG_BPF_SYSCALL */ +void __bpf_free_used_btfs (struct bpf_prog_aux *aux, +struct btf_mod_pair *used_btfs,u32 len); +static inline struct bpf_prog *bpf_prog_get_type (u32 ufd,enum bpf_prog_type type) {
include/linux/bpf_verifier.h +3 -0
@@ -340,6 +340,7 @@ struct bpf_insn_aux_data { };#define MAX_USED_MAPS 64/* max number of maps accessed by one eBPF program */ +#define MAX_USED_BTFS 64/* max number of BTFs accessed by one BPF program */ #define BPF_VERIFIER_TMP_LOG_SIZE 1024
@@ -398,7 +399,9 @@ struct bpf_verifier_env {struct bpf_verifier_state_list **explored_states;/* search pruning optimization */ struct bpf_verifier_state_list *free_list;struct bpf_map *used_maps[MAX_USED_MAPS ];/* array of map's used by eBPF program */ +struct btf_mod_pair used_btfs[MAX_USED_BTFS ];/* array of BTF's used by BPF program */ u32 used_map_cnt;/* number of used maps */ +u32 used_btf_cnt;/* number of used BTF objects */ u32 id_gen;/* used to generate unique reg IDs */ bool allow_ptr_leaks;bool allow_ptr_to_map_access;
include/linux/btf.h +3 -0
@@ -91,6 +91,9 @@ int btf_type_snprintf_show(const struct btf *btf, u32 type_id, void *obj,int btf_get_fd_by_id (u32 id);u32 btf_obj_id (const struct btf *btf);bool btf_is_kernel (const struct btf *btf); +bool btf_is_module (const struct btf *btf); +struct module *btf_try_get_module (const struct btf *btf); +u32 btf_nr_types (const struct btf *btf);bool btf_member_is_reg_int (const struct btf *btf,const struct btf_type *s,const struct btf_member *m,u32 expected_offset,u32 expected_size);
kernel/bpf/btf.c +29 -2
@@ -458,7 +458,7 @@ static bool btf_type_is_datasec(const struct btf_type *t)return BTF_INFO_KIND (t->info) ==BTF_KIND_DATASEC ; } -static u32 btf_nr_types_total (const struct btf *btf) +u32 btf_nr_types (const struct btf *btf) {u32 total =0 ;
@@ -476,7 +476,7 @@ s32 btf_find_by_name_kind(const struct btf *btf, const char *name, u8 kind)const char *tname;u32 i, total; - total =btf_nr_types_total (btf); + total =btf_nr_types (btf);for (i =1 ; i < total; i++) { t =btf_type_by_id (btf, i);if (BTF_INFO_KIND (t->info) != kind)
@@ -5743,6 +5743,11 @@ bool btf_is_kernel(const struct btf *btf)return btf->kernel_btf; } +bool btf_is_module (const struct btf *btf) +{ +return btf->kernel_btf &&strcmp (btf->name,"vmlinux" ) !=0 ; +} +static int btf_id_cmp_func (const void *a,const void *b) {const int *pa = a, *pb = b;
@@ -5877,3 +5882,25 @@ static int __init btf_module_init(void)fs_initcall (btf_module_init);#endif /* CONFIG_DEBUG_INFO_BTF_MODULES */ + +struct module *btf_try_get_module (const struct btf *btf) +{ +struct module *res =NULL ; +#ifdef CONFIG_DEBUG_INFO_BTF_MODULES +struct btf_module *btf_mod, *tmp; + +mutex_lock (&btf_module_mutex); +list_for_each_entry_safe (btf_mod, tmp, &btf_modules, list) { +if (btf_mod->btf != btf) +continue ; + +if (try_module_get (btf_mod->module)) + res = btf_mod->module; + +break ; + } +mutex_unlock (&btf_module_mutex); +#endif + +return res; +}
kernel/bpf/core.c +23 -0
@@ -2119,6 +2119,28 @@ static void bpf_free_used_maps(struct bpf_prog_aux *aux)kfree (aux->used_maps); } +void __bpf_free_used_btfs (struct bpf_prog_aux *aux, +struct btf_mod_pair *used_btfs,u32 len) +{ +#ifdef CONFIG_BPF_SYSCALL +struct btf_mod_pair *btf_mod; +u32 i; + +for (i =0 ; i < len; i++) { + btf_mod = &used_btfs[i]; +if (btf_mod->module) +module_put (btf_mod->module); +btf_put (btf_mod->btf); + } +#endif +} + +static void bpf_free_used_btfs (struct bpf_prog_aux *aux) +{ +__bpf_free_used_btfs (aux, aux->used_btfs, aux->used_btf_cnt); +kfree (aux->used_btfs); +} +static void bpf_prog_free_deferred (struct work_struct *work) {struct bpf_prog_aux *aux;
@@ -2126,6 +2148,7 @@ static void bpf_prog_free_deferred(struct work_struct *work) aux = container_of(work, struct bpf_prog_aux, work);bpf_free_used_maps (aux); +bpf_free_used_btfs (aux);if (bpf_prog_is_dev_bound (aux))bpf_prog_offload_destroy (aux->prog);#ifdef CONFIG_PERF_EVENTS
kernel/bpf/verifier.c +121 -28
240 lines not on this page · raw message
Signature · 1 line
2.24.1
Re: [PATCH v2 bpf-next 5/7] bpf: support BPF ksym variables in kernel modules
Quoted 10 lines · Andrii Nakryiko
Add support for directly accessing kernel module variables from BPF programs using special ldimm64 instructions. This functionality builds upon vmlinux ksym support, but extends ldimm64 with src_reg=BPF_PSEUDO_BTF_ID to allow specifying kernel module BTF's FD in insn[1].imm field.
During BPF program load time, verifier will resolve FD to BTF object and will take reference on BTF object itself and, for module BTFs, corresponding module as well, to make sure it won't be unloaded from under running BPF program. The mechanism used is similar to how
bpf_progkeeps track of usedbpf_maps.
Quoted 7 lines
One interesting change is also in how per-CPU variable is determined. The logic is to find .data..percpu data section in provided BTF, but both vmlinux and module each have their own .data..percpu entries in BTF. So for module's case, the search for DATASEC record needs to look at only module's added BTF types. This is implemented with custom search function.
Signed-off-by Andrii Nakryiko <[email protected]>
Ack with a minor nit below.
Quoted 9 lines
--- include/linux/bpf.h | 10 +++ include/linux/bpf_verifier.h | 3 + include/linux/btf.h | 3 + kernel/bpf/btf.c | 31 +++++++- kernel/bpf/core.c | 23 ++++++ kernel/bpf/verifier.c | 149 ++++++++++++++++++++++++++++------- 6 files changed, 189 insertions(+), 30 deletions(-)
[...]
Quoted 112 lines
/* replace pseudo
btf_idwith kernel symbol address */ static int check_pseudo_btf_id(structbpf_verifier_env*env,
structbpf_insn*insn,kernel/bpf/verifier.c +34
-24@@ -9710,48 +9735,57 @@ static int check_pseudo_btf_id(struct bpf_verifier_env *env, {const struct btf_var_secinfo *vsi;const struct btf_type *datasec; +struct btf_mod_pair *btf_mod;const struct btf_type *t;const char *sym_name;bool percpu = false;u32 type, id = insn->imm; +struct btf *btf;s32 datasec_id;u64 addr; -int i; +int i, btf_fd, err; -if (!btf_vmlinux) { -verbose (env,"kernel is missing BTF, make sure CONFIG_DEBUG_INFO_BTF=y is specified in Kconfig.\n" ); -return -EINVAL ; - } - -if (insn[1 ].imm !=0 ) { -verbose (env,"reserved field (insn[1].imm) is used in pseudo_btf_id ldimm64 insn.\n" ); -return -EINVAL ; + btf_fd = insn[1 ].imm; +if (btf_fd) { + btf =btf_get_by_fd (btf_fd); +if (IS_ERR (btf)) { +verbose (env,"invalid module BTF object FD specified.\n" ); +return -EINVAL ; + } + }else { +if (!btf_vmlinux) { +verbose (env,"kernel is missing BTF, make sure CONFIG_DEBUG_INFO_BTF=y is specified in Kconfig.\n" ); +return -EINVAL ; + } + btf = btf_vmlinux; +btf_get (btf); } - t =btf_type_by_id (btf_vmlinux, id); + t =btf_type_by_id (btf, id);if (!t) {verbose (env,"ldimm64 insn specifies invalid btf_id %d.\n" , id); -return -ENOENT ; + err = -ENOENT ; + goto err_put; }if (!btf_type_is_var (t)) { -verbose (env,"pseudo btf_id %d in ldimm64 isn't KIND_VAR.\n" , - id); -return -EINVAL ; +verbose (env,"pseudo btf_id %d in ldimm64 isn't KIND_VAR.\n" , id); + err = -EINVAL ; + goto err_put; } - sym_name =btf_name_by_offset (btf_vmlinux, t->name_off); + sym_name =btf_name_by_offset (btf, t->name_off); addr =kallsyms_lookup_name (sym_name);if (!addr) {verbose (env,"ldimm64 failed to find the address for kernel symbol '%s'.\n" , sym_name); -return -ENOENT ; + err = -ENOENT ; + goto err_put; } - datasec_id =btf_find_by_name_kind (btf_vmlinux,".data..percpu" , -BTF_KIND_DATASEC ); + datasec_id =find_btf_percpu_datasec (btf);if (datasec_id >0 ) { - datasec =btf_type_by_id (btf_vmlinux, datasec_id); + datasec =btf_type_by_id (btf, datasec_id);for_each_vsi (i, datasec, vsi) {if (vsi->type == id) { percpu = true;@@ -9764,10 +9798,10 @@ static int check_pseudo_btf_id(struct bpf_verifier_env *env, insn[1 ].imm = addr >>32 ; type = t->type; - t =btf_type_skip_modifiers (btf_vmlinux, type,NULL ); + t =btf_type_skip_modifiers (btf, type,NULL );if (percpu) { aux->btf_var.reg_type =PTR_TO_PERCPU_BTF_ID ; - aux->btf_var.btf = btf_vmlinux; + aux->btf_var.btf = btf; aux->btf_var.btf_id = type; }else if (!btf_type_is_struct (t)) {const struct btf_type *ret;@@ -9775,21 +9809,54 @@ static int check_pseudo_btf_id(struct bpf_verifier_env *env,u32 tsize;/* resolve the type size of ksym. */ - ret =btf_resolve_size (btf_vmlinux, t, &tsize); + ret =btf_resolve_size (btf, t, &tsize);if (IS_ERR (ret)) { - tname =btf_name_by_offset (btf_vmlinux, t->name_off); + tname =btf_name_by_offset (btf, t->name_off);verbose (env,"ldimm64 unable to resolve the size of type '%s': %ld\n" , tname,PTR_ERR (ret)); -return -EINVAL ; + err = -EINVAL ; + goto err_put; } aux->btf_var.reg_type =PTR_TO_MEM ; aux->btf_var.mem_size = tsize; }else { aux->btf_var.reg_type =PTR_TO_BTF_ID ;
kernel/bpf/verifier.c static int check_pseudo_btf_id(struct bpf_verifier_env *env, · line 9832
Quoted 10 lines
kernel/bpf/verifier.c +7
-1- aux->btf_var.btf = btf_vmlinux; + aux->btf_var.btf = btf; aux->btf_var.btf_id = type; } + +/* check whether we recorded this BTF (and maybe module) already */ +for (i =0 ; i < env->used_btf_cnt; i++) { +if (env->used_btfs[i].btf == btf) { +btf_put (btf); +return 0 ;
An alternative way is to change the above code as
err = 0; goto err_put;
Quoted 29 lines
kernel/bpf/verifier.c +26
-0+ } + } + +if (env->used_btf_cnt >=MAX_USED_BTFS ) { + err = -E2BIG ; + goto err_put; + } + + btf_mod = &env->used_btfs[env->used_btf_cnt]; + btf_mod->btf = btf; + btf_mod->module =NULL ; + +/* if we reference variables from kernel module, bump its refcount */ +if (btf_is_module (btf)) { + btf_mod->module =btf_try_get_module (btf); +if (!btf_mod->module) { + err = -ENXIO ; + goto err_put; + } + } + + env->used_btf_cnt++; +return 0 ; +err_put: +btf_put (btf); +return err; }
[...]
Re: [PATCH v2 bpf-next 5/7] bpf: support BPF ksym variables in kernel modules
Quoted 39 lines · Yonghong Song
Quoted 10 lines · Andrii Nakryiko
Add support for directly accessing kernel module variables from BPF programs using special ldimm64 instructions. This functionality builds upon vmlinux ksym support, but extends ldimm64 with src_reg=BPF_PSEUDO_BTF_ID to allow specifying kernel module BTF's FD in insn[1].imm field.
During BPF program load time, verifier will resolve FD to BTF object and will take reference on BTF object itself and, for module BTFs, corresponding module as well, to make sure it won't be unloaded from under running BPF program. The mechanism used is similar to how
bpf_progkeeps track of usedbpf_maps.Quoted 7 lines
One interesting change is also in how per-CPU variable is determined. The logic is to find .data..percpu data section in provided BTF, but both vmlinux and module each have their own .data..percpu entries in BTF. So for module's case, the search for DATASEC record needs to look at only module's added BTF types. This is implemented with custom search function.
Signed-off-by Andrii Nakryiko <[email protected]>Ack with a minor nit below.
Acked-by Yonghong Song <[email protected]>Quoted 9 lines
--- include/linux/bpf.h | 10 +++ include/linux/bpf_verifier.h | 3 + include/linux/btf.h | 3 + kernel/bpf/btf.c | 31 +++++++- kernel/bpf/core.c | 23 ++++++ kernel/bpf/verifier.c | 149 ++++++++++++++++++++++++++++------- 6 files changed, 189 insertions(+), 30 deletions(-)[...]
Quoted 3 lines
/* replace pseudo
btf_idwith kernel symbol address */ static int check_pseudo_btf_id(structbpf_verifier_env*env,
structbpf_insn*insn,
[...]
Quoted 13 lines
kernel/bpf/verifier.c static int check_pseudo_btf_id(struct bpf_verifier_env *env, · line 9832
Quoted 12 lines
} else { aux->btf_var.reg_type = PTR_TO_BTF_ID;kernel/bpf/verifier.c +7
-1- aux->btf_var.btf = btf_vmlinux; + aux->btf_var.btf = btf; aux->btf_var.btf_id = type; } + +/* check whether we recorded this BTF (and maybe module) already */ +for (i =0 ; i < env->used_btf_cnt; i++) { +if (env->used_btfs[i].btf == btf) { +btf_put (btf); +return 0 ;
Quoted 3 lines
An alternative way is to change the above code as
err = 0; goto err_put;
I didn't do it, because it's not really an error case, which err_put implies. If in the future we'll have some more clean up to do, it might make sense, I suppose.
Quoted 31 lines
Quoted 30 lines
kernel/bpf/verifier.c +26
-0+ } + } + +if (env->used_btf_cnt >=MAX_USED_BTFS ) { + err = -E2BIG ; + goto err_put; + } + + btf_mod = &env->used_btfs[env->used_btf_cnt]; + btf_mod->btf = btf; + btf_mod->module =NULL ; + +/* if we reference variables from kernel module, bump its refcount */ +if (btf_is_module (btf)) { + btf_mod->module =btf_try_get_module (btf); +if (!btf_mod->module) { + err = -ENXIO ; + goto err_put; + } + } + + env->used_btf_cnt++; +return 0 ; +err_put: +btf_put (btf); +return err; }[...]
Re: [PATCH v2 bpf-next 5/7] bpf: support BPF ksym variables in kernel modules
Quoted 56 lines · Andrii Nakryiko
Quoted 39 lines · Yonghong Song
Quoted 10 lines · Andrii Nakryiko
Add support for directly accessing kernel module variables from BPF programs using special ldimm64 instructions. This functionality builds upon vmlinux ksym support, but extends ldimm64 with src_reg=BPF_PSEUDO_BTF_ID to allow specifying kernel module BTF's FD in insn[1].imm field.
During BPF program load time, verifier will resolve FD to BTF object and will take reference on BTF object itself and, for module BTFs, corresponding module as well, to make sure it won't be unloaded from under running BPF program. The mechanism used is similar to how
bpf_progkeeps track of usedbpf_maps.Quoted 7 lines
One interesting change is also in how per-CPU variable is determined. The logic is to find .data..percpu data section in provided BTF, but both vmlinux and module each have their own .data..percpu entries in BTF. So for module's case, the search for DATASEC record needs to look at only module's added BTF types. This is implemented with custom search function.
Signed-off-by Andrii Nakryiko <[email protected]>Ack with a minor nit below.
Acked-by Yonghong Song <[email protected]>Quoted 9 lines
--- include/linux/bpf.h | 10 +++ include/linux/bpf_verifier.h | 3 + include/linux/btf.h | 3 + kernel/bpf/btf.c | 31 +++++++- kernel/bpf/core.c | 23 ++++++ kernel/bpf/verifier.c | 149 ++++++++++++++++++++++++++++------- 6 files changed, 189 insertions(+), 30 deletions(-)[...]
Quoted 3 lines
/* replace pseudo
btf_idwith kernel symbol address */ static int check_pseudo_btf_id(structbpf_verifier_env*env,
structbpf_insn*insn,[...]
Quoted 13 lines
Quoted 12 lines
} else { aux->btf_var.reg_type = PTR_TO_BTF_ID;kernel/bpf/verifier.c +7
-1- aux->btf_var.btf = btf_vmlinux; + aux->btf_var.btf = btf; aux->btf_var.btf_id = type; } + +/* check whether we recorded this BTF (and maybe module) already */ +for (i =0 ; i < env->used_btf_cnt; i++) { +if (env->used_btfs[i].btf == btf) { +btf_put (btf); +return 0 ;
Quoted 7 lines
Quoted 3 lines
An alternative way is to change the above code as
err = 0; goto err_put;I didn't do it, because it's not really an error case, which
err_putimplies. If in the future we'll have some more clean up to do, it might make sense, I suppose.
You can change label err_put to btf_put, so this way, btf_put() will only show up in one place. But I won't insist on this.
Quoted 32 lines
Quoted 32 lines
Quoted 31 lines
kernel/bpf/verifier.c +26
-0+ } + } + +if (env->used_btf_cnt >=MAX_USED_BTFS ) { + err = -E2BIG ; + goto err_put; + } + + btf_mod = &env->used_btfs[env->used_btf_cnt]; + btf_mod->btf = btf; + btf_mod->module =NULL ; + +/* if we reference variables from kernel module, bump its refcount */ +if (btf_is_module (btf)) { + btf_mod->module =btf_try_get_module (btf); +if (!btf_mod->module) { + err = -ENXIO ; + goto err_put; + } + } + + env->used_btf_cnt++; +return 0 ; +err_put: +btf_put (btf); +return err; }[...]
Re: [PATCH v2 bpf-next 5/7] bpf: support BPF ksym variables in kernel modules
In reply to Andrii NakryikoQuoted 26 lines · Andrii Nakryiko
Add support for directly accessing kernel module variables from BPF programs using special ldimm64 instructions. This functionality builds upon vmlinux ksym support, but extends ldimm64 with src_reg=BPF_PSEUDO_BTF_ID to allow specifying kernel module BTF's FD in insn[1].imm field.
During BPF program load time, verifier will resolve FD to BTF object and will take reference on BTF object itself and, for module BTFs, corresponding module as well, to make sure it won't be unloaded from under running BPF program. The mechanism used is similar to how
bpf_progkeeps track of usedbpf_maps.One interesting change is also in how per-CPU variable is determined. The logic is to find .data..percpu data section in provided BTF, but both vmlinux and module each have their own .data..percpu entries in BTF. So for module's case, the search for DATASEC record needs to look at only module's added BTF types. This is implemented with custom search function.
Signed-off-by Andrii Nakryiko <[email protected]>--- include/linux/bpf.h | 10 +++ include/linux/bpf_verifier.h | 3 + include/linux/btf.h | 3 + kernel/bpf/btf.c | 31 +++++++- kernel/bpf/core.c | 23 ++++++ kernel/bpf/verifier.c | 149 ++++++++++++++++++++++++++++------- 6 files changed, 189 insertions(+), 30 deletions(-)
[...]
Quoted 5 lines
kernel/bpf/verifier.c +0
-0
kernel/bpf/verifier.c static int do_check(struct bpf_verifier_env *env) · line 9711
Quoted 9 lines
kernel/bpf/verifier.c +6
-0@@ -9703,6 +9703,31 @@ static int do_check(struct bpf_verifier_env *env)return 0 ; } +static int find_btf_percpu_datasec (struct btf *btf) +{ +const struct btf_type *t; +const char *tname; +int i, n; +
It would be good to add a short comment here explaining the reason why the search for DATASEC in the module case needs to skip entries.
Quoted 18 lines
kernel/bpf/verifier.c +18
-0+ n =btf_nr_types (btf); +if (btf_is_module (btf)) + i =btf_nr_types (btf_vmlinux); +else + i =1 ; + +for (; i < n; i++) { + t =btf_type_by_id (btf, i); +if (BTF_INFO_KIND (t->info) !=BTF_KIND_DATASEC ) +continue ; + + tname =btf_name_by_offset (btf, t->name_off); +if (!strcmp (tname,".data..percpu" )) +return i; + } + +return -ENOENT ; +}
[...]
Quoted 2 lines
2.24.1
Re: [PATCH v2 bpf-next 5/7] bpf: support BPF ksym variables in kernel modules
Quoted 3 lines · Hao Luo
top posting your Ack? :)
Quoted 38 lines · Andrii Nakryiko
Quoted 26 lines
Add support for directly accessing kernel module variables from BPF programs using special ldimm64 instructions. This functionality builds upon vmlinux ksym support, but extends ldimm64 with src_reg=BPF_PSEUDO_BTF_ID to allow specifying kernel module BTF's FD in insn[1].imm field.
During BPF program load time, verifier will resolve FD to BTF object and will take reference on BTF object itself and, for module BTFs, corresponding module as well, to make sure it won't be unloaded from under running BPF program. The mechanism used is similar to how
bpf_progkeeps track of usedbpf_maps.One interesting change is also in how per-CPU variable is determined. The logic is to find .data..percpu data section in provided BTF, but both vmlinux and module each have their own .data..percpu entries in BTF. So for module's case, the search for DATASEC record needs to look at only module's added BTF types. This is implemented with custom search function.
Signed-off-by Andrii Nakryiko <[email protected]>--- include/linux/bpf.h | 10 +++ include/linux/bpf_verifier.h | 3 + include/linux/btf.h | 3 + kernel/bpf/btf.c | 31 +++++++- kernel/bpf/core.c | 23 ++++++ kernel/bpf/verifier.c | 149 ++++++++++++++++++++++++++++------- 6 files changed, 189 insertions(+), 30 deletions(-)[...]
Quoted 8 lines
kernel/bpf/verifier.c +0
-0@@ -9703,6 +9703,31 @@ static int do_check(struct bpf_verifier_env *env)return 0 ; }
Quoted 9 lines
kernel/bpf/verifier.c static int do_check(struct bpf_verifier_env *env) · line 9711
Quoted 6 lines
kernel/bpf/verifier.c +6
-0+static int find_btf_percpu_datasec (struct btf *btf) +{ +const struct btf_type *t; +const char *tname; +int i, n; +It would be good to add a short comment here explaining the reason why the search for DATASEC in the module case needs to skip entries.
I can copy-paste parts of the commit message with that explanation, if I'll need another version. If not, I can send a follow-up patch.
Quoted 22 lines
Quoted 19 lines
kernel/bpf/verifier.c +18
-0+ n =btf_nr_types (btf); +if (btf_is_module (btf)) + i =btf_nr_types (btf_vmlinux); +else + i =1 ; + +for (; i < n; i++) { + t =btf_type_by_id (btf, i); +if (BTF_INFO_KIND (t->info) !=BTF_KIND_DATASEC ) +continue ; + + tname =btf_name_by_offset (btf, t->name_off); +if (!strcmp (tname,".data..percpu" )) +return i; + } + +return -ENOENT ; +}[...]
Quoted 2 lines
2.24.1
Andrii Nakryiko
maintainerPATCH v2 6/7 libbpf: support kernel module ksym externs
In reply to Andrii NakryikoAdd support for searching for ksym externs not just in vmlinux BTF, but across all module BTFs, similarly to how it's done for CO-RE relocations. Kernels that expose module BTFs through sysfs are assumed to support new ldimm64 instruction extension with BTF FD provided in insn[1].imm field, so no extra feature detection is performed.
--- tools/lib/bpf/libbpf.c | 47 +++++++++++++++++++++++++++--------------- 1 file changed, 30 insertions(+), 17 deletions(-)
tools/lib/bpf/libbpf.c +30 -17
@@ -395,7 +395,8 @@ struct extern_desc {unsigned long long addr;/* target btf_id of the corresponding kernel var. */ -int vmlinux_btf_id; +int kernel_btf_obj_fd; +int kernel_btf_id;/* local btf_id of the ksym extern's type. */ __u32 type_id;
@@ -6162,7 +6163,8 @@ bpf_object__relocate_data(struct bpf_object *obj, struct bpf_program *prog) }else /* EXT_KSYM */ {if (ext->ksym.type_id) {/* typed ksyms */ insn[0 ].src_reg =BPF_PSEUDO_BTF_ID ; - insn[0 ].imm = ext->ksym.vmlinux_btf_id; + insn[0 ].imm = ext->ksym.kernel_btf_id; + insn[1 ].imm = ext->ksym.kernel_btf_obj_fd; }else {/* typeless ksyms */ insn[0 ].imm = (__u32 )ext->ksym.addr; insn[1 ].imm = ext->ksym.addr >>32 ;
@@ -7319,7 +7321,8 @@ static int bpf_object__read_kallsyms_file(struct bpf_object *obj)static int bpf_object__resolve_ksyms_btf_id (struct bpf_object *obj) {struct extern_desc *ext; -int i, id; +struct btf *btf; +int i, j, id, btf_fd, err;for (i =0 ; i < obj->nr_extern; i++) {const struct btf_type *targ_var, *targ_type;
@@ -7331,8 +7334,22 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj)if (ext->type !=EXT_KSYM || !ext->ksym.type_id)continue ; - id =btf__find_by_name_kind (obj->btf_vmlinux, ext->name, -BTF_KIND_VAR ); + btf = obj->btf_vmlinux; + btf_fd =0 ; + id =btf__find_by_name_kind (btf, ext->name,BTF_KIND_VAR ); +if (id == -ENOENT ) { + err =load_module_btfs (obj); +if (err) +return err; + +for (j =0 ; j < obj->btf_module_cnt; j++) { + btf = obj->btf_modules[j].btf; + btf_fd = obj->btf_modules[j].fd; + id =btf__find_by_name_kind (btf, ext->name,BTF_KIND_VAR ); +if (id != -ENOENT ) +break ; + } + }if (id <=0 ) {pr_warn ("extern (ksym) '%s': failed to find BTF ID in vmlinux BTF.\n" , ext->name);
@@ -7343,24 +7360,19 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) local_type_id = ext->ksym.type_id;/* find target type_id */ - targ_var =btf__type_by_id (obj->btf_vmlinux, id); - targ_var_name =btf__name_by_offset (obj->btf_vmlinux, - targ_var->name_off); - targ_type =skip_mods_and_typedefs (obj->btf_vmlinux, - targ_var->type, - &targ_type_id); + targ_var =btf__type_by_id (btf, id); + targ_var_name =btf__name_by_offset (btf, targ_var->name_off); + targ_type =skip_mods_and_typedefs (btf, targ_var->type, &targ_type_id); ret =bpf_core_types_are_compat (obj->btf, local_type_id, - obj->btf_vmlinux, targ_type_id); + btf, targ_type_id);if (ret <=0 ) {const struct btf_type *local_type;const char *targ_name, *local_name; local_type =btf__type_by_id (obj->btf, local_type_id); - local_name =btf__name_by_offset (obj->btf, - local_type->name_off); - targ_name =btf__name_by_offset (obj->btf_vmlinux, - targ_type->name_off); + local_name =btf__name_by_offset (obj->btf, local_type->name_off); + targ_name =btf__name_by_offset (btf, targ_type->name_off); pr_warn("extern (ksym) '%s': incompatible types, expected [%d] %s %s, but kernel has [%d] %s %s\n", ext->name, local_type_id,
@@ -7370,7 +7382,8 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) } ext->is_set = true; - ext->ksym.vmlinux_btf_id = id; + ext->ksym.kernel_btf_obj_fd = btf_fd; + ext->ksym.kernel_btf_id = id;pr_debug ("extern (ksym) '%s': resolved to [%d] %s %s\n" , ext->name, id,btf_kind_str (targ_var), targ_var_name); }
Signature · 1 line
2.24.1
Re: [PATCH v2 bpf-next 6/7] libbpf: support kernel module ksym externs
Quoted 52 lines · Andrii Nakryiko
Add support for searching for ksym externs not just in vmlinux BTF, but across all module BTFs, similarly to how it's done for CO-RE relocations. Kernels that expose module BTFs through sysfs are assumed to support new ldimm64 instruction extension with BTF FD provided in insn[1].imm field, so no extra feature detection is performed.
Signed-off-by Andrii Nakryiko <[email protected]>--- tools/lib/bpf/libbpf.c | 47 +++++++++++++++++++++++++++--------------- 1 file changed, 30 insertions(+), 17 deletions(-)tools/lib/bpf/libbpf.c +7
-5@@ -395,7 +395,8 @@ struct extern_desc {unsigned long long addr;/* target btf_id of the corresponding kernel var. */ -int vmlinux_btf_id; +int kernel_btf_obj_fd; +int kernel_btf_id;/* local btf_id of the ksym extern's type. */ __u32 type_id;@@ -6162,7 +6163,8 @@ bpf_object__relocate_data(struct bpf_object *obj, struct bpf_program *prog) }else /* EXT_KSYM */ {if (ext->ksym.type_id) {/* typed ksyms */ insn[0 ].src_reg =BPF_PSEUDO_BTF_ID ; - insn[0 ].imm = ext->ksym.vmlinux_btf_id; + insn[0 ].imm = ext->ksym.kernel_btf_id; + insn[1 ].imm = ext->ksym.kernel_btf_obj_fd; }else {/* typeless ksyms */ insn[0 ].imm = (__u32 )ext->ksym.addr; insn[1 ].imm = ext->ksym.addr >>32 ;@@ -7319,7 +7321,8 @@ static int bpf_object__read_kallsyms_file(struct bpf_object *obj)static int bpf_object__resolve_ksyms_btf_id (struct bpf_object *obj) {struct extern_desc *ext; -int i, id; +struct btf *btf; +int i, j, id, btf_fd, err;for (i =0 ; i < obj->nr_extern; i++) {const struct btf_type *targ_var, *targ_type;@@ -7331,8 +7334,22 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj)if (ext->type !=EXT_KSYM || !ext->ksym.type_id)continue ; - id =btf__find_by_name_kind (obj->btf_vmlinux, ext->name, -BTF_KIND_VAR ); + btf = obj->btf_vmlinux;
tools/lib/bpf/libbpf.c static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) · line 7347
Quoted 10 lines
tools/lib/bpf/libbpf.c +10
-0+ btf_fd =0 ; + id =btf__find_by_name_kind (btf, ext->name,BTF_KIND_VAR ); +if (id == -ENOENT ) { + err =load_module_btfs (obj); +if (err) +return err; + +for (j =0 ; j < obj->btf_module_cnt; j++) { + btf = obj->btf_modules[j].btf; + btf_fd = obj->btf_modules[j].fd;
Do we have possibility btf_fd == 0 here?
Quoted 50 lines
tools/lib/bpf/libbpf.c +13
-12+ id =btf__find_by_name_kind (btf, ext->name,BTF_KIND_VAR ); +if (id != -ENOENT ) +break ; + } + }if (id <=0 ) {pr_warn ("extern (ksym) '%s': failed to find BTF ID in vmlinux BTF.\n" , ext->name);@@ -7343,24 +7360,19 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) local_type_id = ext->ksym.type_id;/* find target type_id */ - targ_var =btf__type_by_id (obj->btf_vmlinux, id); - targ_var_name =btf__name_by_offset (obj->btf_vmlinux, - targ_var->name_off); - targ_type =skip_mods_and_typedefs (obj->btf_vmlinux, - targ_var->type, - &targ_type_id); + targ_var =btf__type_by_id (btf, id); + targ_var_name =btf__name_by_offset (btf, targ_var->name_off); + targ_type =skip_mods_and_typedefs (btf, targ_var->type, &targ_type_id); ret =bpf_core_types_are_compat (obj->btf, local_type_id, - obj->btf_vmlinux, targ_type_id); + btf, targ_type_id);if (ret <=0 ) {const struct btf_type *local_type;const char *targ_name, *local_name; local_type =btf__type_by_id (obj->btf, local_type_id); - local_name =btf__name_by_offset (obj->btf, - local_type->name_off); - targ_name =btf__name_by_offset (obj->btf_vmlinux, - targ_type->name_off); + local_name =btf__name_by_offset (obj->btf, local_type->name_off); + targ_name =btf__name_by_offset (btf, targ_type->name_off); pr_warn("extern (ksym) '%s': incompatible types, expected [%d] %s %s, but kernel has [%d] %s %s\n", ext->name, local_type_id,@@ -7370,7 +7382,8 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) } ext->is_set = true; - ext->ksym.vmlinux_btf_id = id; + ext->ksym.kernel_btf_obj_fd = btf_fd; + ext->ksym.kernel_btf_id = id;pr_debug ("extern (ksym) '%s': resolved to [%d] %s %s\n" , ext->name, id,btf_kind_str (targ_var), targ_var_name); }
Re: [PATCH v2 bpf-next 6/7] libbpf: support kernel module ksym externs
Quoted 53 lines · Yonghong Song
Quoted 49 lines · Andrii Nakryiko
Add support for searching for ksym externs not just in vmlinux BTF, but across all module BTFs, similarly to how it's done for CO-RE relocations. Kernels that expose module BTFs through sysfs are assumed to support new ldimm64 instruction extension with BTF FD provided in insn[1].imm field, so no extra feature detection is performed.
Signed-off-by Andrii Nakryiko <[email protected]>--- tools/lib/bpf/libbpf.c | 47 +++++++++++++++++++++++++++--------------- 1 file changed, 30 insertions(+), 17 deletions(-)tools/lib/bpf/libbpf.c +6
-3@@ -395,7 +395,8 @@ struct extern_desc {unsigned long long addr;/* target btf_id of the corresponding kernel var. */ -int vmlinux_btf_id; +int kernel_btf_obj_fd; +int kernel_btf_id;/* local btf_id of the ksym extern's type. */ __u32 type_id;@@ -6162,7 +6163,8 @@ bpf_object__relocate_data(struct bpf_object *obj, struct bpf_program *prog) }else /* EXT_KSYM */ {if (ext->ksym.type_id) {/* typed ksyms */ insn[0 ].src_reg =BPF_PSEUDO_BTF_ID ; - insn[0 ].imm = ext->ksym.vmlinux_btf_id; + insn[0 ].imm = ext->ksym.kernel_btf_id; + insn[1 ].imm = ext->ksym.kernel_btf_obj_fd; }else {/* typeless ksyms */ insn[0 ].imm = (__u32 )ext->ksym.addr; insn[1 ].imm = ext->ksym.addr >>32 ;@@ -7319,7 +7321,8 @@ static int bpf_object__read_kallsyms_file(struct bpf_object *obj)static int bpf_object__resolve_ksyms_btf_id (struct bpf_object *obj) {struct extern_desc *ext; -int i, id; +struct btf *btf; +int i, j, id, btf_fd, err;for (i =0 ; i < obj->nr_extern; i++) {const struct btf_type *targ_var, *targ_type;@@ -7331,8 +7334,22 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj)if (ext->type !=EXT_KSYM || !ext->ksym.type_id)continue ;
Quoted 15 lines
tools/lib/bpf/libbpf.c static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) · line 7347
Quoted 13 lines
tools/lib/bpf/libbpf.c +11
-2- id =btf__find_by_name_kind (obj->btf_vmlinux, ext->name, -BTF_KIND_VAR ); + btf = obj->btf_vmlinux; + btf_fd =0 ; + id =btf__find_by_name_kind (btf, ext->name,BTF_KIND_VAR ); +if (id == -ENOENT ) { + err =load_module_btfs (obj); +if (err) +return err; + +for (j =0 ; j < obj->btf_module_cnt; j++) { + btf = obj->btf_modules[j].btf; + btf_fd = obj->btf_modules[j].fd;Do we have possibility
btf_fd== 0 here?
Extremely unlikely. But if we are really worried about 0 fd, we should handle that in a centralized fashion in libbpf. I.e., for any operation that can return FD, check if that FD is 0, and if yes, dup() it. And then make everything call that helper. So in the context of this patch I'm just ignoring such possibility.
Quoted 51 lines
Quoted 51 lines
tools/lib/bpf/libbpf.c +13
-12+ id =btf__find_by_name_kind (btf, ext->name,BTF_KIND_VAR ); +if (id != -ENOENT ) +break ; + } + }if (id <=0 ) {pr_warn ("extern (ksym) '%s': failed to find BTF ID in vmlinux BTF.\n" , ext->name);@@ -7343,24 +7360,19 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) local_type_id = ext->ksym.type_id;/* find target type_id */ - targ_var =btf__type_by_id (obj->btf_vmlinux, id); - targ_var_name =btf__name_by_offset (obj->btf_vmlinux, - targ_var->name_off); - targ_type =skip_mods_and_typedefs (obj->btf_vmlinux, - targ_var->type, - &targ_type_id); + targ_var =btf__type_by_id (btf, id); + targ_var_name =btf__name_by_offset (btf, targ_var->name_off); + targ_type =skip_mods_and_typedefs (btf, targ_var->type, &targ_type_id); ret =bpf_core_types_are_compat (obj->btf, local_type_id, - obj->btf_vmlinux, targ_type_id); + btf, targ_type_id);if (ret <=0 ) {const struct btf_type *local_type;const char *targ_name, *local_name; local_type =btf__type_by_id (obj->btf, local_type_id); - local_name =btf__name_by_offset (obj->btf, - local_type->name_off); - targ_name =btf__name_by_offset (obj->btf_vmlinux, - targ_type->name_off); + local_name =btf__name_by_offset (obj->btf, local_type->name_off); + targ_name =btf__name_by_offset (btf, targ_type->name_off); pr_warn("extern (ksym) '%s': incompatible types, expected [%d] %s %s, but kernel has [%d] %s %s\n", ext->name, local_type_id,@@ -7370,7 +7382,8 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) } ext->is_set = true; - ext->ksym.vmlinux_btf_id = id; + ext->ksym.kernel_btf_obj_fd = btf_fd; + ext->ksym.kernel_btf_id = id;pr_debug ("extern (ksym) '%s': resolved to [%d] %s %s\n" , ext->name, id,btf_kind_str (targ_var), targ_var_name); }
Re: [PATCH v2 bpf-next 6/7] libbpf: support kernel module ksym externs
Quoted 70 lines · Andrii Nakryiko
Quoted 53 lines · Yonghong Song
Quoted 49 lines · Andrii Nakryiko
Add support for searching for ksym externs not just in vmlinux BTF, but across all module BTFs, similarly to how it's done for CO-RE relocations. Kernels that expose module BTFs through sysfs are assumed to support new ldimm64 instruction extension with BTF FD provided in insn[1].imm field, so no extra feature detection is performed.
Signed-off-by Andrii Nakryiko <[email protected]>--- tools/lib/bpf/libbpf.c | 47 +++++++++++++++++++++++++++--------------- 1 file changed, 30 insertions(+), 17 deletions(-)tools/lib/bpf/libbpf.c +6
-3@@ -395,7 +395,8 @@ struct extern_desc {unsigned long long addr;/* target btf_id of the corresponding kernel var. */ -int vmlinux_btf_id; +int kernel_btf_obj_fd; +int kernel_btf_id;/* local btf_id of the ksym extern's type. */ __u32 type_id;@@ -6162,7 +6163,8 @@ bpf_object__relocate_data(struct bpf_object *obj, struct bpf_program *prog) }else /* EXT_KSYM */ {if (ext->ksym.type_id) {/* typed ksyms */ insn[0 ].src_reg =BPF_PSEUDO_BTF_ID ; - insn[0 ].imm = ext->ksym.vmlinux_btf_id; + insn[0 ].imm = ext->ksym.kernel_btf_id; + insn[1 ].imm = ext->ksym.kernel_btf_obj_fd; }else {/* typeless ksyms */ insn[0 ].imm = (__u32 )ext->ksym.addr; insn[1 ].imm = ext->ksym.addr >>32 ;@@ -7319,7 +7321,8 @@ static int bpf_object__read_kallsyms_file(struct bpf_object *obj)static int bpf_object__resolve_ksyms_btf_id (struct bpf_object *obj) {struct extern_desc *ext; -int i, id; +struct btf *btf; +int i, j, id, btf_fd, err;for (i =0 ; i < obj->nr_extern; i++) {const struct btf_type *targ_var, *targ_type;@@ -7331,8 +7334,22 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj)if (ext->type !=EXT_KSYM || !ext->ksym.type_id)continue ;Quoted 15 lines
tools/lib/bpf/libbpf.c static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) · line 7347
Quoted 13 lines
tools/lib/bpf/libbpf.c +11
-2- id =btf__find_by_name_kind (obj->btf_vmlinux, ext->name, -BTF_KIND_VAR ); + btf = obj->btf_vmlinux; + btf_fd =0 ; + id =btf__find_by_name_kind (btf, ext->name,BTF_KIND_VAR ); +if (id == -ENOENT ) { + err =load_module_btfs (obj); +if (err) +return err; + +for (j =0 ; j < obj->btf_module_cnt; j++) { + btf = obj->btf_modules[j].btf; + btf_fd = obj->btf_modules[j].fd;Do we have possibility
btf_fd== 0 here?
Quoted 5 lines
Extremely unlikely. But if we are really worried about 0 fd, we should handle that in a centralized fashion in libbpf. I.e., for any operation that can return FD, check if that FD is 0, and if yes,
dup()it. And then make everything call that helper. So in the context of this patch I'm just ignoring such possibility.
Maybe at least add some comments here to document such a possibility?
Quoted 52 lines
Quoted 52 lines
Quoted 52 lines
tools/lib/bpf/libbpf.c +13
-12+ id =btf__find_by_name_kind (btf, ext->name,BTF_KIND_VAR ); +if (id != -ENOENT ) +break ; + } + }if (id <=0 ) {pr_warn ("extern (ksym) '%s': failed to find BTF ID in vmlinux BTF.\n" , ext->name);@@ -7343,24 +7360,19 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) local_type_id = ext->ksym.type_id;/* find target type_id */ - targ_var =btf__type_by_id (obj->btf_vmlinux, id); - targ_var_name =btf__name_by_offset (obj->btf_vmlinux, - targ_var->name_off); - targ_type =skip_mods_and_typedefs (obj->btf_vmlinux, - targ_var->type, - &targ_type_id); + targ_var =btf__type_by_id (btf, id); + targ_var_name =btf__name_by_offset (btf, targ_var->name_off); + targ_type =skip_mods_and_typedefs (btf, targ_var->type, &targ_type_id); ret =bpf_core_types_are_compat (obj->btf, local_type_id, - obj->btf_vmlinux, targ_type_id); + btf, targ_type_id);if (ret <=0 ) {const struct btf_type *local_type;const char *targ_name, *local_name; local_type =btf__type_by_id (obj->btf, local_type_id); - local_name =btf__name_by_offset (obj->btf, - local_type->name_off); - targ_name =btf__name_by_offset (obj->btf_vmlinux, - targ_type->name_off); + local_name =btf__name_by_offset (obj->btf, local_type->name_off); + targ_name =btf__name_by_offset (btf, targ_type->name_off); pr_warn("extern (ksym) '%s': incompatible types, expected [%d] %s %s, but kernel has [%d] %s %s\n", ext->name, local_type_id,@@ -7370,7 +7382,8 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) } ext->is_set = true; - ext->ksym.vmlinux_btf_id = id; + ext->ksym.kernel_btf_obj_fd = btf_fd; + ext->ksym.kernel_btf_id = id;pr_debug ("extern (ksym) '%s': resolved to [%d] %s %s\n" , ext->name, id,btf_kind_str (targ_var), targ_var_name); }
Re: [PATCH v2 bpf-next 6/7] libbpf: support kernel module ksym externs
Quoted 74 lines · Yonghong Song
Quoted 70 lines · Andrii Nakryiko
Quoted 68 lines · Yonghong Song
Quoted 52 lines · Andrii Nakryiko
Add support for searching for ksym externs not just in vmlinux BTF, but across all module BTFs, similarly to how it's done for CO-RE relocations. Kernels that expose module BTFs through sysfs are assumed to support new ldimm64 instruction extension with BTF FD provided in insn[1].imm field, so no extra feature detection is performed.
Signed-off-by Andrii Nakryiko <[email protected]>--- tools/lib/bpf/libbpf.c | 47 +++++++++++++++++++++++++++--------------- 1 file changed, 30 insertions(+), 17 deletions(-)tools/lib/bpf/libbpf.c +7
-5@@ -395,7 +395,8 @@ struct extern_desc {unsigned long long addr;/* target btf_id of the corresponding kernel var. */ -int vmlinux_btf_id; +int kernel_btf_obj_fd; +int kernel_btf_id;/* local btf_id of the ksym extern's type. */ __u32 type_id;@@ -6162,7 +6163,8 @@ bpf_object__relocate_data(struct bpf_object *obj, struct bpf_program *prog) }else /* EXT_KSYM */ {if (ext->ksym.type_id) {/* typed ksyms */ insn[0 ].src_reg =BPF_PSEUDO_BTF_ID ; - insn[0 ].imm = ext->ksym.vmlinux_btf_id; + insn[0 ].imm = ext->ksym.kernel_btf_id; + insn[1 ].imm = ext->ksym.kernel_btf_obj_fd; }else {/* typeless ksyms */ insn[0 ].imm = (__u32 )ext->ksym.addr; insn[1 ].imm = ext->ksym.addr >>32 ;@@ -7319,7 +7321,8 @@ static int bpf_object__read_kallsyms_file(struct bpf_object *obj)static int bpf_object__resolve_ksyms_btf_id (struct bpf_object *obj) {struct extern_desc *ext; -int i, id; +struct btf *btf; +int i, j, id, btf_fd, err;for (i =0 ; i < obj->nr_extern; i++) {const struct btf_type *targ_var, *targ_type;@@ -7331,8 +7334,22 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj)if (ext->type !=EXT_KSYM || !ext->ksym.type_id)continue ; - id =btf__find_by_name_kind (obj->btf_vmlinux, ext->name, -BTF_KIND_VAR ); + btf = obj->btf_vmlinux;tools/lib/bpf/libbpf.c static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) · line 7347
Quoted 10 lines
tools/lib/bpf/libbpf.c +10
-0+ btf_fd =0 ; + id =btf__find_by_name_kind (btf, ext->name,BTF_KIND_VAR ); +if (id == -ENOENT ) { + err =load_module_btfs (obj); +if (err) +return err; + +for (j =0 ; j < obj->btf_module_cnt; j++) { + btf = obj->btf_modules[j].btf; + btf_fd = obj->btf_modules[j].fd;Do we have possibility
btf_fd== 0 here?
Quoted 6 lines
Quoted 5 lines
Extremely unlikely. But if we are really worried about 0 fd, we should handle that in a centralized fashion in libbpf. I.e., for any operation that can return FD, check if that FD is 0, and if yes,
dup()it. And then make everything call that helper. So in the context of this patch I'm just ignoring such possibility.Maybe at least add some comments here to document such a possibility?
sure, will add
Quoted 53 lines
Quoted 53 lines
Quoted 53 lines
Quoted 53 lines
tools/lib/bpf/libbpf.c +13
-12+ id =btf__find_by_name_kind (btf, ext->name,BTF_KIND_VAR ); +if (id != -ENOENT ) +break ; + } + }if (id <=0 ) {pr_warn ("extern (ksym) '%s': failed to find BTF ID in vmlinux BTF.\n" , ext->name);@@ -7343,24 +7360,19 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) local_type_id = ext->ksym.type_id;/* find target type_id */ - targ_var =btf__type_by_id (obj->btf_vmlinux, id); - targ_var_name =btf__name_by_offset (obj->btf_vmlinux, - targ_var->name_off); - targ_type =skip_mods_and_typedefs (obj->btf_vmlinux, - targ_var->type, - &targ_type_id); + targ_var =btf__type_by_id (btf, id); + targ_var_name =btf__name_by_offset (btf, targ_var->name_off); + targ_type =skip_mods_and_typedefs (btf, targ_var->type, &targ_type_id); ret =bpf_core_types_are_compat (obj->btf, local_type_id, - obj->btf_vmlinux, targ_type_id); + btf, targ_type_id);if (ret <=0 ) {const struct btf_type *local_type;const char *targ_name, *local_name; local_type =btf__type_by_id (obj->btf, local_type_id); - local_name =btf__name_by_offset (obj->btf, - local_type->name_off); - targ_name =btf__name_by_offset (obj->btf_vmlinux, - targ_type->name_off); + local_name =btf__name_by_offset (obj->btf, local_type->name_off); + targ_name =btf__name_by_offset (btf, targ_type->name_off); pr_warn("extern (ksym) '%s': incompatible types, expected [%d] %s %s, but kernel has [%d] %s %s\n", ext->name, local_type_id,@@ -7370,7 +7382,8 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) } ext->is_set = true; - ext->ksym.vmlinux_btf_id = id; + ext->ksym.kernel_btf_obj_fd = btf_fd; + ext->ksym.kernel_btf_id = id;pr_debug ("extern (ksym) '%s': resolved to [%d] %s %s\n" , ext->name, id,btf_kind_str (targ_var), targ_var_name); }
Re: [PATCH v2 bpf-next 6/7] libbpf: support kernel module ksym externs
In reply to Andrii NakryikoQuoted 16 lines · Andrii Nakryiko
Add support for searching for ksym externs not just in vmlinux BTF, but across all module BTFs, similarly to how it's done for CO-RE relocations. Kernels that expose module BTFs through sysfs are assumed to support new ldimm64 instruction extension with BTF FD provided in insn[1].imm field, so no extra feature detection is performed.
Signed-off-by Andrii Nakryiko <[email protected]>--- tools/lib/bpf/libbpf.c | 47 +++++++++++++++++++++++++++--------------- 1 file changed, 30 insertions(+), 17 deletions(-)tools/lib/bpf/libbpf.c +0
-0
[...]
Quoted 11 lines
tools/lib/bpf/libbpf.c +2
-1@@ -7319,7 +7321,8 @@ static int bpf_object__read_kallsyms_file(struct bpf_object *obj)static int bpf_object__resolve_ksyms_btf_id (struct bpf_object *obj) {struct extern_desc *ext; -int i, id; +struct btf *btf; +int i, j, id, btf_fd, err;for (i =0 ; i < obj->nr_extern; i++) {const struct btf_type *targ_var, *targ_type;
tools/lib/bpf/libbpf.c static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) · line 7339
Quoted 8 lines
tools/lib/bpf/libbpf.c +3
-2@@ -7331,8 +7334,22 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj)if (ext->type !=EXT_KSYM || !ext->ksym.type_id)continue ; - id =btf__find_by_name_kind (obj->btf_vmlinux, ext->name, -BTF_KIND_VAR ); + btf = obj->btf_vmlinux; + btf_fd =0 ; + id =btf__find_by_name_kind (btf, ext->name,BTF_KIND_VAR );
Is "if (id <= 0)" better? Just in case, more error code is introduced in future.
Quoted 4 lines
tools/lib/bpf/libbpf.c +4
-0+if (id == -ENOENT ) { + err =load_module_btfs (obj); +if (err) +return err;
tools/lib/bpf/libbpf.c static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) · line 7353
Quoted 10 lines
tools/lib/bpf/libbpf.c +9
-0+ +for (j =0 ; j < obj->btf_module_cnt; j++) { + btf = obj->btf_modules[j].btf; + btf_fd = obj->btf_modules[j].fd; + id =btf__find_by_name_kind (btf, ext->name,BTF_KIND_VAR ); +if (id != -ENOENT ) +break ; + } + }if (id <=0 ) {
Nit: the warning message isn't accurate any more, right? We also searched kernel modules' BTF.
Quoted 3 lines
tools/lib/bpf/libbpf.c +0
-0pr_warn ("extern (ksym) '%s': failed to find BTF ID in vmlinux BTF.\n" , ext->name);@@ -7343,24 +7360,19 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj)
[...]
Quoted 3 lines
--
2.24.1
Re: [PATCH v2 bpf-next 6/7] libbpf: support kernel module ksym externs
Quoted 35 lines · Hao Luo
Quoted 16 lines · Andrii Nakryiko
Add support for searching for ksym externs not just in vmlinux BTF, but across all module BTFs, similarly to how it's done for CO-RE relocations. Kernels that expose module BTFs through sysfs are assumed to support new ldimm64 instruction extension with BTF FD provided in insn[1].imm field, so no extra feature detection is performed.
Signed-off-by Andrii Nakryiko <[email protected]>--- tools/lib/bpf/libbpf.c | 47 +++++++++++++++++++++++++++--------------- 1 file changed, 30 insertions(+), 17 deletions(-)tools/lib/bpf/libbpf.c +0
-0[...]
Quoted 14 lines
tools/lib/bpf/libbpf.c +2
-1@@ -7319,7 +7321,8 @@ static int bpf_object__read_kallsyms_file(struct bpf_object *obj)static int bpf_object__resolve_ksyms_btf_id (struct bpf_object *obj) {struct extern_desc *ext; -int i, id; +struct btf *btf; +int i, j, id, btf_fd, err;for (i =0 ; i < obj->nr_extern; i++) {const struct btf_type *targ_var, *targ_type;@@ -7331,8 +7334,22 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj)if (ext->type !=EXT_KSYM || !ext->ksym.type_id)continue ;
Quoted 7 lines
tools/lib/bpf/libbpf.c static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) · line 7339
Quoted 5 lines
tools/lib/bpf/libbpf.c +3
-2- id =btf__find_by_name_kind (obj->btf_vmlinux, ext->name, -BTF_KIND_VAR ); + btf = obj->btf_vmlinux; + btf_fd =0 ; + id =btf__find_by_name_kind (btf, ext->name,BTF_KIND_VAR );Is "if (id <= 0)" better? Just in case, more error code is introduced in future.
There is id <= 0 right below after special-casing -ENOENT, so all works as you want, no?
Quoted 16 lines
Quoted 5 lines
tools/lib/bpf/libbpf.c +4
-0+if (id == -ENOENT ) { + err =load_module_btfs (obj); +if (err) +return err;tools/lib/bpf/libbpf.c static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj) · line 7353
Quoted 10 lines
tools/lib/bpf/libbpf.c +9
-0+ +for (j =0 ; j < obj->btf_module_cnt; j++) { + btf = obj->btf_modules[j].btf; + btf_fd = obj->btf_modules[j].fd; + id =btf__find_by_name_kind (btf, ext->name,BTF_KIND_VAR ); +if (id != -ENOENT ) +break ; + } + }if (id <=0 ) {
Quoted 2 lines
Nit: the warning message isn't accurate any more, right? We also searched kernel modules' BTF.
Right, how about just "failed to find BTF ID in kernel BTF"? Where "kernel BTF" is "vmlinux BTF or any of kernel modules' BTFs"?
Quoted 9 lines
Quoted 4 lines
tools/lib/bpf/libbpf.c +0
-0pr_warn ("extern (ksym) '%s': failed to find BTF ID in vmlinux BTF.\n" , ext->name);@@ -7343,24 +7360,19 @@ static int bpf_object__resolve_ksyms_btf_id(struct bpf_object *obj)[...]
Quoted 3 lines
--
2.24.1
Andrii Nakryiko
maintainerPATCH v2 7/7 selftests/bpf: test kernel module ksym externs
In reply to Andrii NakryikoAdd per-CPU variable to bpf_testmod.ko and use those from new selftest to validate it works end-to-end.
--- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 3 ++ .../selftests/bpf/prog_tests/ksyms_module.c | 33 +++++++++++++++++++ .../selftests/bpf/progs/test_ksyms_module.c | 26 +++++++++++++++ 3 files changed, 62 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/ksyms_module.c create mode 100644 tools/testing/selftests/bpf/progs/test_ksyms_module.c
tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c +3 -0
@@ -3,6 +3,7 @@#include <linux/error-injection.h> #include <linux/init.h> #include <linux/module.h> +#include <linux/percpu-defs.h> #include <linux/sysfs.h> #include <linux/tracepoint.h> #include "bpf_testmod.h"
@@ -10,6 +11,8 @@#define CREATE_TRACE_POINTS #include "bpf_testmod-events.h" +DEFINE_PER_CPU (int, bpf_testmod_ksym_percpu) =123 ; + noinline ssize_t bpf_testmod_test_read(struct file *file, struct kobject *kobj, struct bin_attribute *bin_attr,
tools/testing/selftests/bpf/prog_tests/ksyms_module.c new file +33 -0
@@ -0,0 +1,33 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2021 Facebook */ + +#include <test_progs.h> +#include <bpf/libbpf.h> +#include <bpf/btf.h> +#include "test_ksyms_module.skel.h" + +static int duration; + +void test_ksyms_module (void ) +{ +struct test_ksyms_module * skel; +struct test_ksyms_module__bss *bss; +int err; + + skel =test_ksyms_module__open_and_load (); +if (CHECK (!skel,"skel_open" ,"failed to open skeleton\n" )) +return ; + bss = skel->bss; + + err =test_ksyms_module__attach (skel); +if (CHECK (err,"skel_attach" ,"skeleton attach failed: %d\n" , err)) + goto cleanup; + +usleep (1 ); + +ASSERT_EQ (bss->triggered, true,"triggered" ); +ASSERT_EQ (bss->out_mod_ksym_global,123 ,"global_ksym_val" ); + +cleanup: +test_ksyms_module__destroy (skel); +}
tools/testing/selftests/bpf/progs/test_ksyms_module.c new file +26 -0
@@ -0,0 +1,26 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2021 Facebook */ + +#include "vmlinux.h" + +#include <bpf/bpf_helpers.h> + +extern const int bpf_testmod_ksym_percpu __ksym; + +int out_mod_ksym_global =0 ; +bool triggered = false; + +SEC("raw_tp/sys_enter") +int handler (const void *ctx) +{ +int *val; +__u32 cpu; + + val = (int *)bpf_this_cpu_ptr (&bpf_testmod_ksym_percpu); + out_mod_ksym_global = *val; + triggered = true; + +return 0 ; +} + +char LICENSE[] SEC("license") = "GPL";
Signature · 1 line
2.24.1
Re: [PATCH v2 bpf-next 7/7] selftests/bpf: test kernel module ksym externs
Quoted 4 lines · Andrii Nakryiko
Add per-CPU variable to bpf_testmod.ko and use those from new selftest to validate it works end-to-end.
Signed-off-by Andrii Nakryiko <[email protected]>
Ack with a nit below.
Quoted 51 lines
--- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 3 ++ .../selftests/bpf/prog_tests/ksyms_module.c | 33 +++++++++++++++++++ .../selftests/bpf/progs/test_ksyms_module.c | 26 +++++++++++++++ 3 files changed, 62 insertions(+)create mode 100644
tools/testing/selftests/bpf/prog_tests/ksyms_module.ccreate mode 100644tools/testing/selftests/bpf/progs/test_ksyms_module.ctools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c +3
-0@@ -3,6 +3,7 @@#include <linux/error-injection.h> #include <linux/init.h> #include <linux/module.h> +#include <linux/percpu-defs.h> #include <linux/sysfs.h> #include <linux/tracepoint.h> #include "bpf_testmod.h" @@ -10,6 +11,8 @@#define CREATE_TRACE_POINTS #include "bpf_testmod-events.h" +DEFINE_PER_CPU (int, bpf_testmod_ksym_percpu) =123 ; + noinline ssize_t bpf_testmod_test_read(struct file *file, struct kobject *kobj, struct bin_attribute *bin_attr,tools/testing/selftests/bpf/prog_tests/ksyms_module.c new file +16
-0@@ -0,0 +1,33 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2021 Facebook */ + +#include <test_progs.h> +#include <bpf/libbpf.h> +#include <bpf/btf.h> +#include "test_ksyms_module.skel.h" + +static int duration; + +void test_ksyms_module (void ) +{ +struct test_ksyms_module * skel; +struct test_ksyms_module__bss *bss; +int err; +
tools/testing/selftests/bpf/prog_tests/ksyms_module.c line 26
Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/ksyms_module.c new file +10
-0+ skel =test_ksyms_module__open_and_load (); +if (CHECK (!skel,"skel_open" ,"failed to open skeleton\n" )) +return ; + bss = skel->bss; + + err =test_ksyms_module__attach (skel); +if (CHECK (err,"skel_attach" ,"skeleton attach failed: %d\n" , err)) + goto cleanup; + +usleep (1 );
The above bss = skel->bss might be moved here for better readability. Or better, you can remove definition bss and just use skel->bss in below two ASSERT_EQs.
Quoted 39 lines
tools/testing/selftests/bpf/prog_tests/ksyms_module.c new file +6
-0+ASSERT_EQ (bss->triggered, true,"triggered" ); +ASSERT_EQ (bss->out_mod_ksym_global,123 ,"global_ksym_val" ); + +cleanup: +test_ksyms_module__destroy (skel); +}tools/testing/selftests/bpf/progs/test_ksyms_module.c new file +26
-0@@ -0,0 +1,26 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2021 Facebook */ + +#include "vmlinux.h" + +#include <bpf/bpf_helpers.h> + +extern const int bpf_testmod_ksym_percpu __ksym; + +int out_mod_ksym_global =0 ; +bool triggered = false; + +SEC("raw_tp/sys_enter") +int handler (const void *ctx) +{ +int *val; +__u32 cpu; + + val = (int *)bpf_this_cpu_ptr (&bpf_testmod_ksym_percpu); + out_mod_ksym_global = *val; + triggered = true; + +return 0 ; +} + +char LICENSE[] SEC("license") = "GPL";
Re: [PATCH v2 bpf-next 7/7] selftests/bpf: test kernel module ksym externs
Quoted 70 lines · Yonghong Song
Quoted 4 lines · Andrii Nakryiko
Add per-CPU variable to bpf_testmod.ko and use those from new selftest to validate it works end-to-end.
Signed-off-by Andrii Nakryiko <[email protected]>Ack with a nit below.
Acked-by Yonghong Song <[email protected]>Quoted 57 lines
--- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 3 ++ .../selftests/bpf/prog_tests/ksyms_module.c | 33 +++++++++++++++++++ .../selftests/bpf/progs/test_ksyms_module.c | 26 +++++++++++++++ 3 files changed, 62 insertions(+)create mode 100644
tools/testing/selftests/bpf/prog_tests/ksyms_module.ccreate mode 100644tools/testing/selftests/bpf/progs/test_ksyms_module.ctools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c +3
-0@@ -3,6 +3,7 @@#include <linux/error-injection.h> #include <linux/init.h> #include <linux/module.h> +#include <linux/percpu-defs.h> #include <linux/sysfs.h> #include <linux/tracepoint.h> #include "bpf_testmod.h" @@ -10,6 +11,8 @@#define CREATE_TRACE_POINTS #include "bpf_testmod-events.h" +DEFINE_PER_CPU (int, bpf_testmod_ksym_percpu) =123 ; + noinline ssize_t bpf_testmod_test_read(struct file *file, struct kobject *kobj, struct bin_attribute *bin_attr,tools/testing/selftests/bpf/prog_tests/ksyms_module.c new file +22
-0@@ -0,0 +1,33 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2021 Facebook */ + +#include <test_progs.h> +#include <bpf/libbpf.h> +#include <bpf/btf.h> +#include "test_ksyms_module.skel.h" + +static int duration; + +void test_ksyms_module (void ) +{ +struct test_ksyms_module * skel; +struct test_ksyms_module__bss *bss; +int err; + + skel =test_ksyms_module__open_and_load (); +if (CHECK (!skel,"skel_open" ,"failed to open skeleton\n" )) +return ; + bss = skel->bss; + + err =test_ksyms_module__attach (skel);
Quoted 8 lines
tools/testing/selftests/bpf/prog_tests/ksyms_module.c line 26
Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/ksyms_module.c new file +4
-0+if (CHECK (err,"skel_attach" ,"skeleton attach failed: %d\n" , err)) + goto cleanup; + +usleep (1 );The above bss =
skel->bssmight be moved here for better readability. Or better, you can remove definition bss and just useskel->bssin below twoASSERT_EQs.
Sure, I'll just inline for such a short test.
Quoted 40 lines
Quoted 40 lines
tools/testing/selftests/bpf/prog_tests/ksyms_module.c new file +6
-0+ASSERT_EQ (bss->triggered, true,"triggered" ); +ASSERT_EQ (bss->out_mod_ksym_global,123 ,"global_ksym_val" ); + +cleanup: +test_ksyms_module__destroy (skel); +}tools/testing/selftests/bpf/progs/test_ksyms_module.c new file +26
-0@@ -0,0 +1,26 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2021 Facebook */ + +#include "vmlinux.h" + +#include <bpf/bpf_helpers.h> + +extern const int bpf_testmod_ksym_percpu __ksym; + +int out_mod_ksym_global =0 ; +bool triggered = false; + +SEC("raw_tp/sys_enter") +int handler (const void *ctx) +{ +int *val; +__u32 cpu; + + val = (int *)bpf_this_cpu_ptr (&bpf_testmod_ksym_percpu); + out_mod_ksym_global = *val; + triggered = true; + +return 0 ; +} + +char LICENSE[] SEC("license") = "GPL";
Re: [PATCH v2 bpf-next 7/7] selftests/bpf: test kernel module ksym externs
In reply to Andrii NakryikoQuoted 108 lines · Andrii Nakryiko
Add per-CPU variable to bpf_testmod.ko and use those from new selftest to validate it works end-to-end.
Signed-off-by Andrii Nakryiko <[email protected]>--- .../selftests/bpf/bpf_testmod/bpf_testmod.c | 3 ++ .../selftests/bpf/prog_tests/ksyms_module.c | 33 +++++++++++++++++++ .../selftests/bpf/progs/test_ksyms_module.c | 26 +++++++++++++++ 3 files changed, 62 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/ksyms_module.c create mode 100644 tools/testing/selftests/bpf/progs/test_ksyms_module.ctools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c +3
-0@@ -3,6 +3,7 @@#include <linux/error-injection.h> #include <linux/init.h> #include <linux/module.h> +#include <linux/percpu-defs.h> #include <linux/sysfs.h> #include <linux/tracepoint.h> #include "bpf_testmod.h" @@ -10,6 +11,8 @@#define CREATE_TRACE_POINTS #include "bpf_testmod-events.h" +DEFINE_PER_CPU (int, bpf_testmod_ksym_percpu) =123 ; + noinline ssize_t bpf_testmod_test_read(struct file *file, struct kobject *kobj, struct bin_attribute *bin_attr,tools/testing/selftests/bpf/prog_tests/ksyms_module.c new file +33
-0@@ -0,0 +1,33 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2021 Facebook */ + +#include <test_progs.h> +#include <bpf/libbpf.h> +#include <bpf/btf.h> +#include "test_ksyms_module.skel.h" + +static int duration; + +void test_ksyms_module (void ) +{ +struct test_ksyms_module * skel; +struct test_ksyms_module__bss *bss; +int err; + + skel =test_ksyms_module__open_and_load (); +if (CHECK (!skel,"skel_open" ,"failed to open skeleton\n" )) +return ; + bss = skel->bss; + + err =test_ksyms_module__attach (skel); +if (CHECK (err,"skel_attach" ,"skeleton attach failed: %d\n" , err)) + goto cleanup; + +usleep (1 ); + +ASSERT_EQ (bss->triggered, true,"triggered" ); +ASSERT_EQ (bss->out_mod_ksym_global,123 ,"global_ksym_val" ); + +cleanup: +test_ksyms_module__destroy (skel); +}tools/testing/selftests/bpf/progs/test_ksyms_module.c new file +26
-1@@ -0,0 +1,26 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2021 Facebook */ + +#include "vmlinux.h" + +#include <bpf/bpf_helpers.h> + +extern const int bpf_testmod_ksym_percpu __ksym; + +int out_mod_ksym_global =0 ; +bool triggered = false; + +SEC("raw_tp/sys_enter") +int handler (const void *ctx) +{ +int *val; +__u32 cpu; + + val = (int *)bpf_this_cpu_ptr (&bpf_testmod_ksym_percpu); + out_mod_ksym_global = *val; + triggered = true; + +return 0 ; +} + +char LICENSE[] SEC("license") = "GPL"; --2.24.1