bpf: Support 64-bit pointers to kfuncs
RFC PATCH v2 1/4 bpf: Introduce BPF_HELPER_CALL
In reply to Ilya LeoshkevichMake the code more readable by introducing a symbolic constant instead of using 0.
--- include/uapi/linux/bpf.h | 4 ++++ kernel/bpf/disasm.c | 2 +- kernel/bpf/verifier.c | 12 +++++++----- tools/include/linux/filter.h | 2 +- tools/include/uapi/linux/bpf.h | 4 ++++ 5 files changed, 17 insertions(+), 7 deletions(-)
include/uapi/linux/bpf.h +4 -0
@@ -1211,6 +1211,10 @@ enum bpf_link_type {*/ #define BPF_PSEUDO_FUNC 4 +/* when bpf_call->src_reg == BPF_HELPER_CALL, bpf_call->imm == index of a bpf +* helper function (see ___BPF_FUNC_MAPPER below for a full list) +*/ +#define BPF_HELPER_CALL 0/* when bpf_call->src_reg == BPF_PSEUDO_CALL, bpf_call->imm == pc-relative * offset to another bpf function */
kernel/bpf/disasm.c +1 -1
@@ -19,7 +19,7 @@ static const char *__func_get_name(const struct bpf_insn_cbs *cbs, {BUILD_BUG_ON (ARRAY_SIZE (func_id_str) != __BPF_FUNC_MAX_ID); -if (!insn->src_reg && +if (insn->src_reg ==BPF_HELPER_CALL && insn->imm >=0 && insn->imm < __BPF_FUNC_MAX_ID && func_id_str[insn->imm])return func_id_str[insn->imm];
kernel/bpf/verifier.c +7 -5
@@ -2947,7 +2947,8 @@ static int backtrack_insn(struct bpf_verifier_env *env, int idx,/* BPF helpers that invoke callback subprogs are * equivalent to BPF_PSEUDO_CALL above */ -if (insn->src_reg ==0 &&is_callback_calling_function (insn->imm)) +if (insn->src_reg ==BPF_HELPER_CALL && +is_callback_calling_function (insn->imm))return -ENOTSUPP ;/* kfunc with imm==0 is invalid and fixup_kfunc_call will * catch this error later. Make backtracking conservative
@@ -7522,7 +7523,7 @@ static int __check_func_call(struct bpf_verifier_env *env, struct bpf_insn *insn }if (insn->code == (BPF_JMP |BPF_CALL ) && - insn->src_reg ==0 && + insn->src_reg ==BPF_HELPER_CALL && insn->imm == BPF_FUNC_timer_set_callback) {struct bpf_verifier_state *async_cb;
@@ -14730,7 +14731,7 @@ static int do_check(struct bpf_verifier_env *env) if (BPF_SRC(insn->code) != BPF_K || (insn->src_reg != BPF_PSEUDO_KFUNC_CALL && insn->off != 0) || - (insn->src_reg != BPF_REG_0 && + (insn->src_reg != BPF_HELPER_CALL && insn->src_reg != BPF_PSEUDO_CALL && insn->src_reg != BPF_PSEUDO_KFUNC_CALL) || insn->dst_reg != BPF_REG_0 ||
@@ -14740,7 +14741,8 @@ static int do_check(struct bpf_verifier_env *env) }if (env->cur_state->active_lock.ptr) { -if ((insn->src_reg ==BPF_REG_0 && insn->imm != BPF_FUNC_spin_unlock) || +if ((insn->src_reg ==BPF_HELPER_CALL && + insn->imm != BPF_FUNC_spin_unlock) || (insn->src_reg ==BPF_PSEUDO_CALL ) || (insn->src_reg ==BPF_PSEUDO_KFUNC_CALL && (insn->off !=0 || !is_bpf_graph_api_kfunc (insn->imm)))) {
@@ -16933,7 +16935,7 @@ static struct bpf_prog *inline_bpf_loop(struct bpf_verifier_env *env,static bool is_bpf_loop_call (struct bpf_insn *insn) {return insn->code == (BPF_JMP |BPF_CALL ) && - insn->src_reg ==0 && + insn->src_reg ==BPF_HELPER_CALL && insn->imm == BPF_FUNC_loop; }
tools/include/linux/filter.h +1 -1
@@ -261,7 +261,7 @@ ((struct bpf_insn ) { \ .code =BPF_JMP |BPF_CALL , \ .dst_reg =0 , \ - .src_reg =0 , \ + .src_reg =BPF_HELPER_CALL , \ .off =0 , \ .imm = ((FUNC ) - BPF_FUNC_unspec) })
tools/include/uapi/linux/bpf.h +4 -0
@@ -1211,6 +1211,10 @@ enum bpf_link_type {*/ #define BPF_PSEUDO_FUNC 4 +/* when bpf_call->src_reg == BPF_HELPER_CALL, bpf_call->imm == index of a bpf +* helper function (see ___BPF_FUNC_MAPPER below for a full list) +*/ +#define BPF_HELPER_CALL 0/* when bpf_call->src_reg == BPF_PSEUDO_CALL, bpf_call->imm == pc-relative * offset to another bpf function */
Signature · 1 line
2.39.1
v2 cover bpf: Support 64-bit pointers to kfuncs
v1: https://lore.kernel.org/bpf/[email protected]/T/#t
v1 -> v2: Add BPF_HELPER_CALL (Stanislav).
Add check_subprogs() cleanup - noticed while reviewing the code for BPF_HELPER_CALL.
Drop WARN_ON_ONCE (Stanislav, Alexei).
Add bpf_jit_get_func_addr() to x86_64 JIT.
Hi,
This series solves the problems outlined in [1, 2, 3]. The main problem is that kfuncs in modules do not fit into bpf_insn.imm on s390x; the secondary problem is that there is a conflict between "abstract" XDP metadata function BTF ids and their "concrete" addresses.
The solution is to keep fkunc BTF ids in bpf_insn.imm, and put the addresses into bpf_kfunc_desc, which does not have size restrictions.
Regtested with test_verifier and test_progs on x86_64 and s390x.
TODO: Need to add bpf_jit_get_func_addr() to arm, sparc and i386 JITs.
[1] https://lore.kernel.org/bpf/Y9%2FyrKZkBK6yzXp+@krava/
[2] https://lore.kernel.org/bpf/[email protected]/
[3] https://lore.kernel.org/bpf/[email protected]/
Best regards,
Ilya
Ilya Leoshkevich (4):
bpf: Introduce BPF_HELPER_CALL
bpf: Use BPF_HELPER_CALL in check_subprogs()
bpf, x86: Use bpf_jit_get_func_addr()
bpf: Support 64-bit pointers to kfuncs
arch/x86/net/bpf_jit_comp.c | 15 ++++-- include/linux/bpf.h | 2 + include/uapi/linux/bpf.h | 4 ++ kernel/bpf/core.c | 21 ++++++-- kernel/bpf/disasm.c | 2 +- kernel/bpf/verifier.c | 95 ++++++++++++---------------------- tools/include/linux/filter.h | 2 +- tools/include/uapi/linux/bpf.h | 4 ++ 8 files changed, 75 insertions(+), 70 deletions(-)
Signature · 1 line
2.39.1
RFC PATCH v2 3/4 bpf, x86: Use bpf_jit_get_func_addr()
Preparation for moving kfunc address from bpf_insn.imm.
--- arch/x86/net/bpf_jit_comp.c | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-)
arch/x86/net/bpf_jit_comp.c +12 -3
@@ -964,7 +964,8 @@ static void emit_shiftx(u8 **pprog, u32 dst_reg, u8 src_reg, bool is64, u8 op)#define INSN_SZ_DIFF (((addrs[i] - addrs[i - 1]) - (prog - temp)))static int do_jit (struct bpf_prog *bpf_prog,int *addrs,u8 *image,u8 *rw_image, -int oldproglen,struct jit_context *ctx,bool jmp_padding) +int oldproglen,struct jit_context *ctx,bool jmp_padding, +bool extra_pass) {bool tail_call_reachable = bpf_prog->aux->tail_call_reachable;struct bpf_insn *insn = bpf_prog->insnsi;
@@ -1000,9 +1001,11 @@ static int do_jit(struct bpf_prog *bpf_prog, int *addrs, u8 *image, u8 *rw_imageconst s32 imm32 = insn->imm;u32 dst_reg = insn->dst_reg;u32 src_reg = insn->src_reg; +bool func_addr_fixed;u8 b2 =0 , b3 =0 ;u8 *start_of_ldx;s64 jmp_offset; +u64 func_addr;s16 insn_off;u8 jmp_cond;u8 *func;
@@ -1536,7 +1539,12 @@ st: if (is_imm8(insn->off))case BPF_JMP |BPF_CALL : {int offs; - func = (u8 *) __bpf_call_base + imm32; + err =bpf_jit_get_func_addr (bpf_prog, insn, extra_pass, + &func_addr, + &func_addr_fixed); +if (err <0 ) +return err; + func = (u8 *)(unsigned long )func_addr;if (tail_call_reachable) {/* mov rax, qword ptr [rbp - rounded_stack_depth - 8] */ EMIT3_off32(0x48, 0x8B, 0x85,
@@ -2518,7 +2526,8 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *prog)for (pass =0 ; pass <MAX_PASSES || image; pass++) {if (!padding && pass >=PADDING_PASSES ) padding = true; - proglen =do_jit (prog, addrs, image, rw_image, oldproglen, &ctx, padding); + proglen =do_jit (prog, addrs, image, rw_image, oldproglen, &ctx, + padding, extra_pass);if (proglen <=0 ) { out_image: image =NULL ;
Signature · 1 line
2.39.1
RFC PATCH v2 4/4 bpf: Support 64-bit pointers to kfuncs
In reply to Ilya Leoshkevichtest_ksyms_module fails to emit a kfunc call targeting a module on s390x, because the verifier stores the difference between kfunc address and __bpf_call_base in bpf_insn.imm, which is s32, and modules are roughly (1 << 42) bytes away from the kernel on s390x.
Fix by keeping BTF id in bpf_insn.imm for BPF_PSEUDO_KFUNC_CALLs, and storing the absolute address in bpf_kfunc_desc, which JITs retrieve as usual by calling bpf_jit_get_func_addr().
Introduce bpf_get_kfunc_addr() instead of exposing both find_kfunc_desc() and struct bpf_kfunc_desc.
This also fixes the problem with XDP metadata functions outlined in the description of commit 63d7b53ab59f ("s390/bpf: Implement bpf_jit_supports_kfunc_call()") by replacing address lookups with BTF id lookups. This eliminates the inconsistency between "abstract" XDP metadata functions' BTF ids and their concrete addresses.
--- include/linux/bpf.h | 2 ++ kernel/bpf/core.c | 21 ++++++++++-- kernel/bpf/verifier.c | 79 +++++++++++++------------------------------ 3 files changed, 44 insertions(+), 58 deletions(-)
include/linux/bpf.h +2 -0
@@ -2227,6 +2227,8 @@ bool bpf_prog_has_kfunc_call(const struct bpf_prog *prog);const struct btf_func_model *bpf_jit_find_kfunc_model (const struct bpf_prog *prog,const struct bpf_insn *insn); +int bpf_get_kfunc_addr (const struct bpf_prog *prog,u32 func_id,u16 offset, +u8 **func_addr);struct bpf_core_ctx {struct bpf_verifier_log *log;const struct btf *btf;
kernel/bpf/core.c +18 -3
@@ -1185,10 +1185,12 @@ int bpf_jit_get_func_addr(const struct bpf_prog *prog, {s16 off = insn->off;s32 imm = insn->imm; +bool fixed;u8 *addr; +int err; - *func_addr_fixed = insn->src_reg !=BPF_PSEUDO_CALL ; -if (!*func_addr_fixed) { +switch (insn->src_reg) { +case BPF_PSEUDO_CALL :/* Place-holder address till the last pass has collected * all addresses for JITed subprograms in which case we * can pick them up from prog->aux.
@@ -1200,15 +1202,28 @@ int bpf_jit_get_func_addr(const struct bpf_prog *prog, addr = (u8 *)prog->aux->func[off]->bpf_func; else return -EINVAL; - }else { + fixed = false; +break ; +case BPF_HELPER_CALL :/* Address of a BPF helper call. Since part of the core * kernel, it's always at a fixed location. __bpf_call_base * and the helper with imm relative to it are both in core * kernel. */ addr = (u8 *)__bpf_call_base + imm; + fixed = true; +break ; +case BPF_PSEUDO_KFUNC_CALL : + err =bpf_get_kfunc_addr (prog, imm, off, &addr); +if (err) +return err; + fixed = true; +break ; +default : +return -EINVAL ; } + *func_addr_fixed = fixed; *func_addr = (unsigned long )addr;return 0 ; }
kernel/bpf/verifier.c +24 -55
156 lines not on this page · raw message
Signature · 1 line
2.39.1
RFC PATCH v2 2/4 bpf: Use BPF_HELPER_CALL in check_subprogs()
In reply to Ilya LeoshkevichThe condition src_reg != BPF_PSEUDO_CALL && imm == BPF_FUNC_tail_call may be satisfied by a kfunc call. This would lead to unnecessarily setting has_tail_call. Use src_reg == BPF_HELPER_CALL instead.
--- kernel/bpf/verifier.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/bpf/verifier.c +2 -2
@@ -2475,8 +2475,8 @@ static int check_subprogs(struct bpf_verifier_env *env)u8 code = insn[i].code;if (code == (BPF_JMP |BPF_CALL ) && - insn[i].imm == BPF_FUNC_tail_call && - insn[i].src_reg !=BPF_PSEUDO_CALL ) + insn[i].src_reg ==BPF_HELPER_CALL && + insn[i].imm == BPF_FUNC_tail_call) subprog[cur_subprog].has_tail_call = true;if (BPF_CLASS (code) ==BPF_LD && (BPF_MODE (code) ==BPF_ABS ||BPF_MODE (code) ==BPF_IND ))
Signature · 1 line
2.39.1
Re: [PATCH RFC bpf-next v2 1/4] bpf: Introduce BPF_HELPER_CALL
In reply to Ilya LeoshkevichQuoted 19 lines · Ilya Leoshkevich
Make the code more readable by introducing a symbolic constant instead of using 0.
Suggested-by Stanislav Fomichev <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>--- include/uapi/linux/bpf.h | 4 ++++ kernel/bpf/disasm.c | 2 +- kernel/bpf/verifier.c | 12 +++++++----- tools/include/linux/filter.h | 2 +- tools/include/uapi/linux/bpf.h | 4 ++++ 5 files changed, 17 insertions(+), 7 deletions(-)include/uapi/linux/bpf.h +0
-0
include/uapi/linux/bpf.h enum bpf_link_type { · line 1217
Quoted 7 lines
include/uapi/linux/bpf.h +4
-0@@ -1211,6 +1211,10 @@ enum bpf_link_type {*/ #define BPF_PSEUDO_FUNC 4 +/* when bpf_call->src_reg == BPF_HELPER_CALL, bpf_call->imm == index of a bpf +* helper function (see ___BPF_FUNC_MAPPER below for a full list) +*/ +#define BPF_HELPER_CALL 0
I don't like this "cleanup".
The code reads fine as-is.
Re: [PATCH RFC bpf-next v2 1/4] bpf: Introduce BPF_HELPER_CALL
Quoted 23 lines · Alexei Starovoitov
Quoted 22 lines · Ilya Leoshkevich
Make the code more readable by introducing a symbolic constant instead of using 0.
Suggested-by Stanislav Fomichev <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>--- include/uapi/linux/bpf.h | 4 ++++ kernel/bpf/disasm.c | 2 +- kernel/bpf/verifier.c | 12 +++++++----- tools/include/linux/filter.h | 2 +- tools/include/uapi/linux/bpf.h | 4 ++++ 5 files changed, 17 insertions(+), 7 deletions(-)include/uapi/linux/bpf.h +0
-0@@ -1211,6 +1211,10 @@ enum bpf_link_type {*/ #define BPF_PSEUDO_FUNC 4
Quoted 8 lines
include/uapi/linux/bpf.h enum bpf_link_type { · line 1214
Quoted 1 line
include/uapi/linux/bpf.h +1
-0+/* when bpf_call->src_reg == BPF_HELPER_CALL, bpf_call->imm == index of a bpf
include/uapi/linux/bpf.h enum bpf_link_type { · line 1217
Quoted 3 lines
include/uapi/linux/bpf.h +3
-0+* helper function (see ___BPF_FUNC_MAPPER below for a full list) +*/ +#define BPF_HELPER_CALL 0I don't like this "cleanup".
The code reads fine as-is.
Even in the context of patch 4? There would be the following switch without BPF_HELPER_CALL:
switch (insn->src_reg) {
case 0:
... break;
case BPF_PSEUDO_CALL:
... break;
case BPF_PSEUDO_KFUNC_CALL:
... break; }
That 'case 0' feels like it deserves a name. But up to you, I'm fine either way.
Re: [PATCH RFC bpf-next v2 1/4] bpf: Introduce BPF_HELPER_CALL
Quoted 47 lines · Stanislav Fomichev
Quoted 24 lines · Alexei Starovoitov
Quoted 22 lines · Ilya Leoshkevich
Make the code more readable by introducing a symbolic constant instead of using 0.
Suggested-by Stanislav Fomichev <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>--- include/uapi/linux/bpf.h | 4 ++++ kernel/bpf/disasm.c | 2 +- kernel/bpf/verifier.c | 12 +++++++----- tools/include/linux/filter.h | 2 +- tools/include/uapi/linux/bpf.h | 4 ++++ 5 files changed, 17 insertions(+), 7 deletions(-)include/uapi/linux/bpf.h +0
-0@@ -1211,6 +1211,10 @@ enum bpf_link_type {*/ #define BPF_PSEUDO_FUNC 4Quoted 8 lines
include/uapi/linux/bpf.h enum bpf_link_type { · line 1214
Quoted 1 line
include/uapi/linux/bpf.h +1
-0+/* when bpf_call->src_reg == BPF_HELPER_CALL, bpf_call->imm == index of a bpf
include/uapi/linux/bpf.h enum bpf_link_type { · line 1217
Quoted 3 lines
include/uapi/linux/bpf.h +3
-0+* helper function (see ___BPF_FUNC_MAPPER below for a full list) +*/ +#define BPF_HELPER_CALL 0I don't like this "cleanup".
The code reads fine as-is.Even in the context of patch 4? There would be the following switch without
BPF_HELPER_CALL:switch (
insn->src_reg) {
case 0:... break;case
BPF_PSEUDO_CALL:... break;
Quoted 7 lines
case
BPF_PSEUDO_KFUNC_CALL:... break; }That 'case 0' feels like it deserves a name. But up to you, I'm fine either way.
It's philosophical.
Some people insist on if (ptr == NULL). I insist on if (!ptr). That's why canonical bpf progs are written as:
val = bpf_map_lookup();
if (!val) ...
zero is zero. It doesn't need #define.
Re: [PATCH RFC bpf-next v2 1/4] bpf: Introduce BPF_HELPER_CALL
Quoted 57 lines · Alexei Starovoitov
Quoted 26 lines · Stanislav Fomichev
Quoted 24 lines · Alexei Starovoitov
Quoted 22 lines · Ilya Leoshkevich
Make the code more readable by introducing a symbolic constant instead of using 0.
Suggested-by Stanislav Fomichev <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>--- include/uapi/linux/bpf.h | 4 ++++ kernel/bpf/disasm.c | 2 +- kernel/bpf/verifier.c | 12 +++++++----- tools/include/linux/filter.h | 2 +- tools/include/uapi/linux/bpf.h | 4 ++++ 5 files changed, 17 insertions(+), 7 deletions(-)include/uapi/linux/bpf.h +0
-0@@ -1211,6 +1211,10 @@ enum bpf_link_type {*/ #define BPF_PSEUDO_FUNC 4Quoted 1 line
Quoted 1 line
include/uapi/linux/bpf.h enum bpf_link_type { · line 1214
Quoted 1 line
include/uapi/linux/bpf.h +1
-0+/* when bpf_call->src_reg == BPF_HELPER_CALL, bpf_call->imm == index
Quoted 20 lines
Quoted 7 lines
of a bpf
include/uapi/linux/bpf.h enum bpf_link_type { · line 1217
Quoted 3 lines
include/uapi/linux/bpf.h +3
-0+* helper function (see ___BPF_FUNC_MAPPER below for a full list) +*/ +#define BPF_HELPER_CALL 0I don't like this "cleanup".
The code reads fine as-is.Even in the context of patch 4? There would be the following switch without
BPF_HELPER_CALL:switch (
insn->src_reg) {
case 0:... break;case
BPF_PSEUDO_CALL:... break;Quoted 7 lines
case
BPF_PSEUDO_KFUNC_CALL:... break; }That 'case 0' feels like it deserves a name. But up to you, I'm fine either way.
Quoted 6 lines
It's philosophical.
Some people insist on if (ptr == NULL). I insist on if (!ptr). That's why canonical bpf progs are written as:
val =bpf_map_lookup();
if (!val) ...
zero is zero. It doesn't need #define.
Are you sure we still want to apply the same logic here for src_reg? I agree that doing src_reg vs !src_reg made sense when we had a "helper" vs "non-helper" (bpf2bpf) situation. However now this src_reg feels more like an enum. And since we have an enum value for 1 and 2, it feels natural to have another one for 0?
That second patch from the series ([0]) might be a good example on why we actually need it. I'm assuming at some point we've had:
#define BPF_PSEUDO_CALL 1
So we ended up writing src_reg != BPF_PSEUDO_CALL instead of actually doing src_reg == BPF_HELPER_CALL (aka src_reg == 0). Afterwards, we've added BPF_PSEUDO_KFUNC_CALL=2 which broke our previous src_reg vs !src_reg assumptions...
[0]: https://lore.kernel.org/bpf/[email protected]/T/#mf87a26ef48a909b62ce950639acfdf5b296b487b
On Thu, Feb 16, 2023 at 12:59:31AM +0100, Ilya Leoshkevich wrote:
SNIP
Quoted 16 lines
kernel/bpf/verifier.c +1
-1@@ -2115,8 +2115,8 @@ static int add_subprog(struct bpf_verifier_env *env, int off)struct bpf_kfunc_desc {struct btf_func_model func_model;u32 func_id; -s32 imm;u16 offset; +unsigned long addr; };struct bpf_kfunc_btf {@@ -2166,6 +2166,19 @@ find_kfunc_desc(const struct bpf_prog *prog, u32 func_id, u16 offset) sizeof(tab->descs[0]), kfunc_desc_cmp_by_id_off);
kernel/bpf/verifier.c find_kfunc_desc(const struct bpf_prog *prog, u32 func_id, u16 offset) · line 2176
Quoted 10 lines
kernel/bpf/verifier.c +8
-0} +int bpf_get_kfunc_addr (const struct bpf_prog *prog,u32 func_id,u16 offset, +u8 **func_addr) +{ +const struct bpf_kfunc_desc *desc; + + desc =find_kfunc_desc (prog, func_id, offset); +if (!desc) +return -EFAULT ;
should we warn here? this should alwayss succeed, right?
jirka
Quoted 5 lines
kernel/bpf/verifier.c +5
-0+ + *func_addr = (u8 *)desc->addr; +return 0 ; +} +
SNIP
Quoted 28 lines · Jiri Olsa
On Thu, Feb 16, 2023 at 12:59:31AM +0100, Ilya Leoshkevich wrote:
SNIP
Quoted 24 lines
kernel/bpf/verifier.c +1
-1@@ -2115,8 +2115,8 @@ static int add_subprog(struct bpf_verifier_env *env, int off) struct bpf_kfunc_desc { struct btf_func_model func_model; u32 func_id; - s32 imm; u16 offset; + unsigned long addr; };
structbpf_kfunc_btf{kernel/bpf/verifier.c +0
-0@@ -2166,6 +2166,19 @@ find_kfunc_desc(const struct bpf_prog *prog, u32 func_id, u16 offset) sizeof(tab->descs[0]), kfunc_desc_cmp_by_id_off); }
+int bpf_get_kfunc_addr(const structbpf_prog*prog, u32func_id, u16 offset,
+ u8 **func_addr)
Quoted 8 lines
kernel/bpf/verifier.c find_kfunc_desc(const struct bpf_prog *prog, u32 func_id, u16 offset) · line 2176
Quoted 6 lines
kernel/bpf/verifier.c +6
-0+{ + const struct bpf_kfunc_desc *desc; + + desc = find_kfunc_desc(prog, func_id, offset); + if (!desc) + return -EFAULT;should we warn here? this should alwayss succeed, right?
Hi Jiri!
This was discussed here:
https://lore.kernel.org/bpf/[email protected]/T/#m3a4748997d31f6840c50b0bf2ccafe9d24f9218f
The conclusion was that the existing code does not warn in situations like this, so we should not warn here either.
Best regards,
Ilya
Quoted 10 lines
jirka
Quoted 5 lines
kernel/bpf/verifier.c +5
-0+ + *func_addr = (u8 *)desc->addr; + return 0; +} +SNIP
Re: [PATCH RFC bpf-next v2 1/4] bpf: Introduce BPF_HELPER_CALL
In reply to Stanislav FomichevQuoted 94 lines · Stanislav Fomichev
Quoted 65 lines · Alexei Starovoitov
Quoted 29 lines · Stanislav Fomichev
Quoted 27 lines · Alexei Starovoitov
Quoted 24 lines · Ilya Leoshkevich
Make the code more readable by introducing a symbolic constant
instead of using 0.Suggested-by Stanislav Fomichev <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>---
include/uapi/linux/bpf.h | 4 ++++
kernel/bpf/disasm.c | 2 +-
kernel/bpf/verifier.c | 12 +++++++-----
tools/include/linux/filter.h | 2 +-
tools/include/uapi/linux/bpf.h | 4 ++++5 files changed, 17 insertions(+), 7 deletions(-)include/uapi/linux/bpf.h +0
-0@@ -1211,6 +1211,10 @@ enum bpf_link_type {*/ #define BPF_PSEUDO_FUNC 4Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
include/uapi/linux/bpf.h +1
-0+/* when bpf_call->src_reg == BPF_HELPER_CALL, bpf_call->imm ==
index
Quoted 22 lines
Quoted 8 lines
of a bpf
Quoted 4 lines
+ * helper function (see
___BPF_FUNC_MAPPERbelow for a full list)
+ */
+#define BPF_HELPER_CALL 0I don't like this "cleanup".
The code reads fine as-is.Even in the context of patch 4? There would be the following switch
withoutBPF_HELPER_CALL:switch (
insn->src_reg) {
case 0:
...
break;case
BPF_PSEUDO_CALL:
...
break;Quoted 8 lines
case
BPF_PSEUDO_KFUNC_CALL:
...
break;
}That 'case 0' feels like it deserves a name. But up to you, I'm fine
either way.Quoted 6 lines
It's philosophical.
Some people insist on if (ptr == NULL). I insist on if (!ptr). That's why canonical bpf progs are written as:
val =bpf_map_lookup();
if (!val) ...
zero is zero. It doesn't need #define.Are you sure we still want to apply the same logic here for
src_reg? I
agree that doingsrc_regvs !src_reg made sense when we had a "helper"
vs "non-helper" (bpf2bpf) situation. However now thissrc_regfeels more
like an enum. And since we have an enum value for 1 and 2, it feels natural to have another one for 0?That second patch from the series ([0]) might be a good example on why
we actually need it. I'm assuming at some point we've had:
#defineBPF_PSEUDO_CALL1So we ended up writing
src_reg != BPF_PSEUDO_CALLinstead of actually
doingsrc_reg == BPF_HELPER_CALL(akasrc_reg == 0). Afterwards, we've added BPF_PSEUDO_KFUNC_CALL=2 which broke our previoussrc_regvs !src_reg assumptions...
Quoted 2 lines
[0]:
https://lore.kernel.org/bpf/[email protected]/T/#mf87a26ef48a909b62ce950639acfdf5b296b487b
FWIW the helper checks before this series had inconsistent style:
- !insn->src_reg
- insn->src_reg == 0
- insn->src_reg != BPF_REG_0
- insn[i].src_reg != BPF_PSEUDO_CALL
Now at least it's the same style everywhere, and also it's easy to grep for "where do we check for helper calls".
Re: [PATCH RFC bpf-next v2 1/4] bpf: Introduce BPF_HELPER_CALL
Quoted 101 lines · Ilya Leoshkevich
Quoted 94 lines · Stanislav Fomichev
Quoted 65 lines · Alexei Starovoitov
Quoted 29 lines · Stanislav Fomichev
Quoted 27 lines · Alexei Starovoitov
Quoted 24 lines · Ilya Leoshkevich
Make the code more readable by introducing a symbolic constant
instead of using 0.Suggested-by Stanislav Fomichev <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>--- include/uapi/linux/bpf.h | 4 ++++ kernel/bpf/disasm.c | 2 +- kernel/bpf/verifier.c | 12 +++++++----- tools/include/linux/filter.h | 2 +- tools/include/uapi/linux/bpf.h | 4 ++++ 5 files changed, 17 insertions(+), 7 deletions(-)include/uapi/linux/bpf.h +0
-0@@ -1211,6 +1211,10 @@ enum bpf_link_type {*/ #define BPF_PSEUDO_FUNC 4Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
include/uapi/linux/bpf.h +1
-0+/* when bpf_call->src_reg == BPF_HELPER_CALL, bpf_call->imm ==
index
Quoted 22 lines
Quoted 8 lines
of a bpf
Quoted 4 lines
+ * helper function (see
___BPF_FUNC_MAPPERbelow for a full list)
+ */
+#defineBPF_HELPER_CALL0I don't like this "cleanup".
The code reads fine as-is.Even in the context of patch 4? There would be the following switch
withoutBPF_HELPER_CALL:switch (
insn->src_reg) {
case 0:... break;case
BPF_PSEUDO_CALL:... break;Quoted 8 lines
case
BPF_PSEUDO_KFUNC_CALL:... break; }That 'case 0' feels like it deserves a name. But up to you, I'm fine
either way.Quoted 6 lines
It's philosophical.
Some people insist on if (ptr == NULL). I insist on if (!ptr). That's why canonical bpf progs are written as:
val =bpf_map_lookup();
if (!val) ...
zero is zero. It doesn't need #define.Are you sure we still want to apply the same logic here for
src_reg? I
agree that doingsrc_regvs !src_reg made sense when we had a "helper"
vs "non-helper" (bpf2bpf) situation. However now thissrc_regfeels more
like an enum. And since we have an enum value for 1 and 2, it feels natural to have another one for 0?That second patch from the series ([0]) might be a good example on why
we actually need it. I'm assuming at some point we've had:
#defineBPF_PSEUDO_CALL1So we ended up writing
src_reg != BPF_PSEUDO_CALLinstead of actually
doingsrc_reg == BPF_HELPER_CALL(akasrc_reg == 0). Afterwards, we've added BPF_PSEUDO_KFUNC_CALL=2 which broke our previoussrc_regvs !src_reg assumptions...Quoted 2 lines
[0]:
https://lore.kernel.org/bpf/[email protected]/T/#mf87a26ef48a909b62ce950639acfdf5b296b487bFWIW the helper checks before this series had inconsistent style:
Quoted 7 lines
- !insn->src_reg
-insn->src_reg== 0
-insn->src_reg!=BPF_REG_0
- insn[i].src_reg !=BPF_PSEUDO_CALLNow at least it's the same style everywhere, and also it's easy to grep for "where do we check for helper calls".
The above checks are not equivalent.
Comparing src_reg with BPF_REG_0 makes sense in one context and doesn't in the other.
It's never ok to add stuff to uapi when it works as-is. I also don't buy theoretical arguments about future additions and how something will be cleaner in the future because we predicted it so well today.
Re: [PATCH RFC bpf-next v2 1/4] bpf: Introduce BPF_HELPER_CALL
Quoted 111 lines · Alexei Starovoitov
Quoted 101 lines · Ilya Leoshkevich
Quoted 94 lines · Stanislav Fomichev
Quoted 65 lines · Alexei Starovoitov
Quoted 29 lines · Stanislav Fomichev
Quoted 27 lines · Alexei Starovoitov
Quoted 24 lines · Ilya Leoshkevich
Make the code more readable by introducing a symbolic constant
instead of using 0.Suggested-by Stanislav Fomichev <[email protected]>Signed-off-by Ilya Leoshkevich <[email protected]>--- include/uapi/linux/bpf.h | 4 ++++ kernel/bpf/disasm.c | 2 +- kernel/bpf/verifier.c | 12 +++++++----- tools/include/linux/filter.h | 2 +- tools/include/uapi/linux/bpf.h | 4 ++++ 5 files changed, 17 insertions(+), 7 deletions(-)include/uapi/linux/bpf.h +0
-0@@ -1211,6 +1211,10 @@ enum bpf_link_type {*/ #define BPF_PSEUDO_FUNC 4Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
include/uapi/linux/bpf.h +1
-0+/* when bpf_call->src_reg == BPF_HELPER_CALL, bpf_call->imm ==
index
Quoted 22 lines
Quoted 8 lines
of a bpf
Quoted 4 lines
+ * helper function (see
___BPF_FUNC_MAPPERbelow for a full list)
+ */
+#defineBPF_HELPER_CALL0I don't like this "cleanup".
The code reads fine as-is.Even in the context of patch 4? There would be the following switch
withoutBPF_HELPER_CALL:switch (
insn->src_reg) {
case 0:... break;case
BPF_PSEUDO_CALL:... break;Quoted 8 lines
case
BPF_PSEUDO_KFUNC_CALL:... break; }That 'case 0' feels like it deserves a name. But up to you, I'm fine
either way.Quoted 6 lines
It's philosophical.
Some people insist on if (ptr == NULL). I insist on if (!ptr). That's why canonical bpf progs are written as:
val =bpf_map_lookup();
if (!val) ...
zero is zero. It doesn't need #define.Are you sure we still want to apply the same logic here for
src_reg? I
agree that doingsrc_regvs !src_reg made sense when we had a "helper"
vs "non-helper" (bpf2bpf) situation. However now thissrc_regfeels more
like an enum. And since we have an enum value for 1 and 2, it feels natural to have another one for 0?That second patch from the series ([0]) might be a good example on why
we actually need it. I'm assuming at some point we've had:
#defineBPF_PSEUDO_CALL1So we ended up writing
src_reg != BPF_PSEUDO_CALLinstead of actually
doingsrc_reg == BPF_HELPER_CALL(akasrc_reg == 0). Afterwards, we've added BPF_PSEUDO_KFUNC_CALL=2 which broke our previoussrc_regvs !src_reg assumptions...Quoted 2 lines
[0]:
https://lore.kernel.org/bpf/[email protected]/T/#mf87a26ef48a909b62ce950639acfdf5b296b487bFWIW the helper checks before this series had inconsistent style:
Quoted 7 lines
- !insn->src_reg
-insn->src_reg== 0
-insn->src_reg!=BPF_REG_0
- insn[i].src_reg !=BPF_PSEUDO_CALLNow at least it's the same style everywhere, and also it's easy to grep for "where do we check for helper calls".
Quoted 7 lines
The above checks are not equivalent.
Comparingsrc_regwithBPF_REG_0makes sense in one context and doesn't in the other.
It's never ok to add stuff to uapi when it works as-is. I also don't buy theoretical arguments about future additions and how something will be cleaner in the future because we predicted it so well today.
SG! Then let's maybe respin without this part? I might have derailed the conversation too much from the actual issue :-[