2019-01-26 02:24:44 +03:00
{
" dead code: start " ,
. insns = {
BPF_JMP_IMM ( BPF_JA , 0 , 0 , 2 ) ,
BPF_LDX_MEM ( BPF_B , BPF_REG_8 , BPF_REG_9 , 0 ) ,
BPF_JMP_IMM ( BPF_JA , 0 , 0 , 2 ) ,
BPF_MOV64_IMM ( BPF_REG_0 , 7 ) ,
BPF_JMP_IMM ( BPF_JGE , BPF_REG_0 , 10 , - 4 ) ,
BPF_EXIT_INSN ( ) ,
} ,
2021-05-31 15:34:24 +03:00
. errstr_unpriv = " R9 !read_ok " ,
. result_unpriv = REJECT ,
2019-01-26 02:24:44 +03:00
. result = ACCEPT ,
. retval = 7 ,
} ,
{
" dead code: mid 1 " ,
. insns = {
BPF_MOV64_IMM ( BPF_REG_0 , 7 ) ,
BPF_JMP_IMM ( BPF_JGE , BPF_REG_0 , 0 , 1 ) ,
BPF_JMP_IMM ( BPF_JGE , BPF_REG_0 , 10 , 0 ) ,
BPF_EXIT_INSN ( ) ,
} ,
. result = ACCEPT ,
. retval = 7 ,
} ,
{
" dead code: mid 2 " ,
. insns = {
BPF_RAW_INSN ( BPF_JMP | BPF_CALL , 0 , 0 , 0 , BPF_FUNC_get_prandom_u32 ) ,
BPF_JMP_IMM ( BPF_JSET , BPF_REG_0 , 1 , 4 ) ,
BPF_JMP_IMM ( BPF_JSET , BPF_REG_0 , 1 , 1 ) ,
BPF_JMP_IMM ( BPF_JA , 0 , 0 , 2 ) ,
BPF_MOV64_IMM ( BPF_REG_0 , 7 ) ,
BPF_EXIT_INSN ( ) ,
BPF_MOV64_IMM ( BPF_REG_0 , 1 ) ,
BPF_EXIT_INSN ( ) ,
} ,
. result = ACCEPT ,
. retval = 1 ,
} ,
{
" dead code: end 1 " ,
. insns = {
BPF_MOV64_IMM ( BPF_REG_0 , 7 ) ,
BPF_JMP_IMM ( BPF_JGE , BPF_REG_0 , 10 , 1 ) ,
BPF_EXIT_INSN ( ) ,
BPF_EXIT_INSN ( ) ,
} ,
. result = ACCEPT ,
. retval = 7 ,
} ,
{
" dead code: end 2 " ,
. insns = {
BPF_MOV64_IMM ( BPF_REG_0 , 7 ) ,
BPF_JMP_IMM ( BPF_JGE , BPF_REG_0 , 10 , 1 ) ,
BPF_EXIT_INSN ( ) ,
BPF_MOV64_IMM ( BPF_REG_0 , 12 ) ,
BPF_EXIT_INSN ( ) ,
} ,
. result = ACCEPT ,
. retval = 7 ,
} ,
{
" dead code: end 3 " ,
. insns = {
BPF_MOV64_IMM ( BPF_REG_0 , 7 ) ,
BPF_JMP_IMM ( BPF_JGE , BPF_REG_0 , 8 , 1 ) ,
BPF_EXIT_INSN ( ) ,
BPF_JMP_IMM ( BPF_JGE , BPF_REG_0 , 10 , 1 ) ,
BPF_JMP_IMM ( BPF_JA , 0 , 0 , 1 ) ,
BPF_MOV64_IMM ( BPF_REG_0 , 12 ) ,
BPF_JMP_IMM ( BPF_JA , 0 , 0 , - 5 ) ,
} ,
. result = ACCEPT ,
. retval = 7 ,
} ,
{
" dead code: tail of main + func " ,
. insns = {
BPF_MOV64_IMM ( BPF_REG_0 , 7 ) ,
BPF_JMP_IMM ( BPF_JGE , BPF_REG_0 , 8 , 1 ) ,
BPF_EXIT_INSN ( ) ,
BPF_RAW_INSN ( BPF_JMP | BPF_CALL , 0 , 1 , 0 , 1 ) ,
BPF_EXIT_INSN ( ) ,
BPF_MOV64_IMM ( BPF_REG_0 , 12 ) ,
BPF_EXIT_INSN ( ) ,
} ,
bpf: Support bpf program calling kernel function
This patch adds support to BPF verifier to allow bpf program calling
kernel function directly.
The use case included in this set is to allow bpf-tcp-cc to directly
call some tcp-cc helper functions (e.g. "tcp_cong_avoid_ai()"). Those
functions have already been used by some kernel tcp-cc implementations.
This set will also allow the bpf-tcp-cc program to directly call the
kernel tcp-cc implementation, For example, a bpf_dctcp may only want to
implement its own dctcp_cwnd_event() and reuse other dctcp_*() directly
from the kernel tcp_dctcp.c instead of reimplementing (or
copy-and-pasting) them.
The tcp-cc kernel functions mentioned above will be white listed
for the struct_ops bpf-tcp-cc programs to use in a later patch.
The white listed functions are not bounded to a fixed ABI contract.
Those functions have already been used by the existing kernel tcp-cc.
If any of them has changed, both in-tree and out-of-tree kernel tcp-cc
implementations have to be changed. The same goes for the struct_ops
bpf-tcp-cc programs which have to be adjusted accordingly.
This patch is to make the required changes in the bpf verifier.
First change is in btf.c, it adds a case in "btf_check_func_arg_match()".
When the passed in "btf->kernel_btf == true", it means matching the
verifier regs' states with a kernel function. This will handle the
PTR_TO_BTF_ID reg. It also maps PTR_TO_SOCK_COMMON, PTR_TO_SOCKET,
and PTR_TO_TCP_SOCK to its kernel's btf_id.
In the later libbpf patch, the insn calling a kernel function will
look like:
insn->code == (BPF_JMP | BPF_CALL)
insn->src_reg == BPF_PSEUDO_KFUNC_CALL /* <- new in this patch */
insn->imm == func_btf_id /* btf_id of the running kernel */
[ For the future calling function-in-kernel-module support, an array
of module btf_fds can be passed at the load time and insn->off
can be used to index into this array. ]
At the early stage of verifier, the verifier will collect all kernel
function calls into "struct bpf_kfunc_desc". Those
descriptors are stored in "prog->aux->kfunc_tab" and will
be available to the JIT. Since this "add" operation is similar
to the current "add_subprog()" and looking for the same insn->code,
they are done together in the new "add_subprog_and_kfunc()".
In the "do_check()" stage, the new "check_kfunc_call()" is added
to verify the kernel function call instruction:
1. Ensure the kernel function can be used by a particular BPF_PROG_TYPE.
A new bpf_verifier_ops "check_kfunc_call" is added to do that.
The bpf-tcp-cc struct_ops program will implement this function in
a later patch.
2. Call "btf_check_kfunc_args_match()" to ensure the regs can be
used as the args of a kernel function.
3. Mark the regs' type, subreg_def, and zext_dst.
At the later do_misc_fixups() stage, the new fixup_kfunc_call()
will replace the insn->imm with the function address (relative
to __bpf_call_base). If needed, the jit can find the btf_func_model
by calling the new bpf_jit_find_kfunc_model(prog, insn).
With the imm set to the function address, "bpftool prog dump xlated"
will be able to display the kernel function calls the same way as
it displays other bpf helper calls.
gpl_compatible program is required to call kernel function.
This feature currently requires JIT.
The verifier selftests are adjusted because of the changes in
the verbose log in add_subprog_and_kfunc().
Signed-off-by: Martin KaFai Lau <kafai@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20210325015142.1544736-1-kafai@fb.com
2021-03-25 04:51:42 +03:00
. errstr_unpriv = " loading/calling other bpf or kernel functions are allowed for " ,
2019-01-26 02:24:44 +03:00
. result_unpriv = REJECT ,
. result = ACCEPT ,
. retval = 7 ,
} ,
{
" dead code: tail of main + two functions " ,
. insns = {
BPF_MOV64_IMM ( BPF_REG_0 , 7 ) ,
BPF_JMP_IMM ( BPF_JGE , BPF_REG_0 , 8 , 1 ) ,
BPF_EXIT_INSN ( ) ,
BPF_RAW_INSN ( BPF_JMP | BPF_CALL , 0 , 1 , 0 , 1 ) ,
BPF_EXIT_INSN ( ) ,
BPF_RAW_INSN ( BPF_JMP | BPF_CALL , 0 , 1 , 0 , 1 ) ,
BPF_EXIT_INSN ( ) ,
BPF_MOV64_IMM ( BPF_REG_0 , 12 ) ,
BPF_EXIT_INSN ( ) ,
} ,
bpf: Support bpf program calling kernel function
This patch adds support to BPF verifier to allow bpf program calling
kernel function directly.
The use case included in this set is to allow bpf-tcp-cc to directly
call some tcp-cc helper functions (e.g. "tcp_cong_avoid_ai()"). Those
functions have already been used by some kernel tcp-cc implementations.
This set will also allow the bpf-tcp-cc program to directly call the
kernel tcp-cc implementation, For example, a bpf_dctcp may only want to
implement its own dctcp_cwnd_event() and reuse other dctcp_*() directly
from the kernel tcp_dctcp.c instead of reimplementing (or
copy-and-pasting) them.
The tcp-cc kernel functions mentioned above will be white listed
for the struct_ops bpf-tcp-cc programs to use in a later patch.
The white listed functions are not bounded to a fixed ABI contract.
Those functions have already been used by the existing kernel tcp-cc.
If any of them has changed, both in-tree and out-of-tree kernel tcp-cc
implementations have to be changed. The same goes for the struct_ops
bpf-tcp-cc programs which have to be adjusted accordingly.
This patch is to make the required changes in the bpf verifier.
First change is in btf.c, it adds a case in "btf_check_func_arg_match()".
When the passed in "btf->kernel_btf == true", it means matching the
verifier regs' states with a kernel function. This will handle the
PTR_TO_BTF_ID reg. It also maps PTR_TO_SOCK_COMMON, PTR_TO_SOCKET,
and PTR_TO_TCP_SOCK to its kernel's btf_id.
In the later libbpf patch, the insn calling a kernel function will
look like:
insn->code == (BPF_JMP | BPF_CALL)
insn->src_reg == BPF_PSEUDO_KFUNC_CALL /* <- new in this patch */
insn->imm == func_btf_id /* btf_id of the running kernel */
[ For the future calling function-in-kernel-module support, an array
of module btf_fds can be passed at the load time and insn->off
can be used to index into this array. ]
At the early stage of verifier, the verifier will collect all kernel
function calls into "struct bpf_kfunc_desc". Those
descriptors are stored in "prog->aux->kfunc_tab" and will
be available to the JIT. Since this "add" operation is similar
to the current "add_subprog()" and looking for the same insn->code,
they are done together in the new "add_subprog_and_kfunc()".
In the "do_check()" stage, the new "check_kfunc_call()" is added
to verify the kernel function call instruction:
1. Ensure the kernel function can be used by a particular BPF_PROG_TYPE.
A new bpf_verifier_ops "check_kfunc_call" is added to do that.
The bpf-tcp-cc struct_ops program will implement this function in
a later patch.
2. Call "btf_check_kfunc_args_match()" to ensure the regs can be
used as the args of a kernel function.
3. Mark the regs' type, subreg_def, and zext_dst.
At the later do_misc_fixups() stage, the new fixup_kfunc_call()
will replace the insn->imm with the function address (relative
to __bpf_call_base). If needed, the jit can find the btf_func_model
by calling the new bpf_jit_find_kfunc_model(prog, insn).
With the imm set to the function address, "bpftool prog dump xlated"
will be able to display the kernel function calls the same way as
it displays other bpf helper calls.
gpl_compatible program is required to call kernel function.
This feature currently requires JIT.
The verifier selftests are adjusted because of the changes in
the verbose log in add_subprog_and_kfunc().
Signed-off-by: Martin KaFai Lau <kafai@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20210325015142.1544736-1-kafai@fb.com
2021-03-25 04:51:42 +03:00
. errstr_unpriv = " loading/calling other bpf or kernel functions are allowed for " ,
2019-01-26 02:24:44 +03:00
. result_unpriv = REJECT ,
. result = ACCEPT ,
. retval = 7 ,
} ,
{
" dead code: function in the middle and mid of another func " ,
. insns = {
BPF_MOV64_IMM ( BPF_REG_1 , 7 ) ,
BPF_RAW_INSN ( BPF_JMP | BPF_CALL , 0 , 1 , 0 , 3 ) ,
BPF_EXIT_INSN ( ) ,
BPF_MOV64_IMM ( BPF_REG_0 , 12 ) ,
BPF_EXIT_INSN ( ) ,
BPF_MOV64_IMM ( BPF_REG_0 , 7 ) ,
BPF_JMP_IMM ( BPF_JGE , BPF_REG_1 , 7 , 1 ) ,
BPF_RAW_INSN ( BPF_JMP | BPF_CALL , 0 , 1 , 0 , - 5 ) ,
BPF_EXIT_INSN ( ) ,
} ,
bpf: Support bpf program calling kernel function
This patch adds support to BPF verifier to allow bpf program calling
kernel function directly.
The use case included in this set is to allow bpf-tcp-cc to directly
call some tcp-cc helper functions (e.g. "tcp_cong_avoid_ai()"). Those
functions have already been used by some kernel tcp-cc implementations.
This set will also allow the bpf-tcp-cc program to directly call the
kernel tcp-cc implementation, For example, a bpf_dctcp may only want to
implement its own dctcp_cwnd_event() and reuse other dctcp_*() directly
from the kernel tcp_dctcp.c instead of reimplementing (or
copy-and-pasting) them.
The tcp-cc kernel functions mentioned above will be white listed
for the struct_ops bpf-tcp-cc programs to use in a later patch.
The white listed functions are not bounded to a fixed ABI contract.
Those functions have already been used by the existing kernel tcp-cc.
If any of them has changed, both in-tree and out-of-tree kernel tcp-cc
implementations have to be changed. The same goes for the struct_ops
bpf-tcp-cc programs which have to be adjusted accordingly.
This patch is to make the required changes in the bpf verifier.
First change is in btf.c, it adds a case in "btf_check_func_arg_match()".
When the passed in "btf->kernel_btf == true", it means matching the
verifier regs' states with a kernel function. This will handle the
PTR_TO_BTF_ID reg. It also maps PTR_TO_SOCK_COMMON, PTR_TO_SOCKET,
and PTR_TO_TCP_SOCK to its kernel's btf_id.
In the later libbpf patch, the insn calling a kernel function will
look like:
insn->code == (BPF_JMP | BPF_CALL)
insn->src_reg == BPF_PSEUDO_KFUNC_CALL /* <- new in this patch */
insn->imm == func_btf_id /* btf_id of the running kernel */
[ For the future calling function-in-kernel-module support, an array
of module btf_fds can be passed at the load time and insn->off
can be used to index into this array. ]
At the early stage of verifier, the verifier will collect all kernel
function calls into "struct bpf_kfunc_desc". Those
descriptors are stored in "prog->aux->kfunc_tab" and will
be available to the JIT. Since this "add" operation is similar
to the current "add_subprog()" and looking for the same insn->code,
they are done together in the new "add_subprog_and_kfunc()".
In the "do_check()" stage, the new "check_kfunc_call()" is added
to verify the kernel function call instruction:
1. Ensure the kernel function can be used by a particular BPF_PROG_TYPE.
A new bpf_verifier_ops "check_kfunc_call" is added to do that.
The bpf-tcp-cc struct_ops program will implement this function in
a later patch.
2. Call "btf_check_kfunc_args_match()" to ensure the regs can be
used as the args of a kernel function.
3. Mark the regs' type, subreg_def, and zext_dst.
At the later do_misc_fixups() stage, the new fixup_kfunc_call()
will replace the insn->imm with the function address (relative
to __bpf_call_base). If needed, the jit can find the btf_func_model
by calling the new bpf_jit_find_kfunc_model(prog, insn).
With the imm set to the function address, "bpftool prog dump xlated"
will be able to display the kernel function calls the same way as
it displays other bpf helper calls.
gpl_compatible program is required to call kernel function.
This feature currently requires JIT.
The verifier selftests are adjusted because of the changes in
the verbose log in add_subprog_and_kfunc().
Signed-off-by: Martin KaFai Lau <kafai@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20210325015142.1544736-1-kafai@fb.com
2021-03-25 04:51:42 +03:00
. errstr_unpriv = " loading/calling other bpf or kernel functions are allowed for " ,
2019-01-26 02:24:44 +03:00
. result_unpriv = REJECT ,
. result = ACCEPT ,
. retval = 7 ,
} ,
{
" dead code: middle of main before call " ,
. insns = {
BPF_MOV64_IMM ( BPF_REG_1 , 2 ) ,
BPF_JMP_IMM ( BPF_JGE , BPF_REG_1 , 2 , 1 ) ,
BPF_MOV64_IMM ( BPF_REG_1 , 5 ) ,
BPF_RAW_INSN ( BPF_JMP | BPF_CALL , 0 , 1 , 0 , 1 ) ,
BPF_EXIT_INSN ( ) ,
BPF_MOV64_REG ( BPF_REG_0 , BPF_REG_1 ) ,
BPF_EXIT_INSN ( ) ,
} ,
bpf: Support bpf program calling kernel function
This patch adds support to BPF verifier to allow bpf program calling
kernel function directly.
The use case included in this set is to allow bpf-tcp-cc to directly
call some tcp-cc helper functions (e.g. "tcp_cong_avoid_ai()"). Those
functions have already been used by some kernel tcp-cc implementations.
This set will also allow the bpf-tcp-cc program to directly call the
kernel tcp-cc implementation, For example, a bpf_dctcp may only want to
implement its own dctcp_cwnd_event() and reuse other dctcp_*() directly
from the kernel tcp_dctcp.c instead of reimplementing (or
copy-and-pasting) them.
The tcp-cc kernel functions mentioned above will be white listed
for the struct_ops bpf-tcp-cc programs to use in a later patch.
The white listed functions are not bounded to a fixed ABI contract.
Those functions have already been used by the existing kernel tcp-cc.
If any of them has changed, both in-tree and out-of-tree kernel tcp-cc
implementations have to be changed. The same goes for the struct_ops
bpf-tcp-cc programs which have to be adjusted accordingly.
This patch is to make the required changes in the bpf verifier.
First change is in btf.c, it adds a case in "btf_check_func_arg_match()".
When the passed in "btf->kernel_btf == true", it means matching the
verifier regs' states with a kernel function. This will handle the
PTR_TO_BTF_ID reg. It also maps PTR_TO_SOCK_COMMON, PTR_TO_SOCKET,
and PTR_TO_TCP_SOCK to its kernel's btf_id.
In the later libbpf patch, the insn calling a kernel function will
look like:
insn->code == (BPF_JMP | BPF_CALL)
insn->src_reg == BPF_PSEUDO_KFUNC_CALL /* <- new in this patch */
insn->imm == func_btf_id /* btf_id of the running kernel */
[ For the future calling function-in-kernel-module support, an array
of module btf_fds can be passed at the load time and insn->off
can be used to index into this array. ]
At the early stage of verifier, the verifier will collect all kernel
function calls into "struct bpf_kfunc_desc". Those
descriptors are stored in "prog->aux->kfunc_tab" and will
be available to the JIT. Since this "add" operation is similar
to the current "add_subprog()" and looking for the same insn->code,
they are done together in the new "add_subprog_and_kfunc()".
In the "do_check()" stage, the new "check_kfunc_call()" is added
to verify the kernel function call instruction:
1. Ensure the kernel function can be used by a particular BPF_PROG_TYPE.
A new bpf_verifier_ops "check_kfunc_call" is added to do that.
The bpf-tcp-cc struct_ops program will implement this function in
a later patch.
2. Call "btf_check_kfunc_args_match()" to ensure the regs can be
used as the args of a kernel function.
3. Mark the regs' type, subreg_def, and zext_dst.
At the later do_misc_fixups() stage, the new fixup_kfunc_call()
will replace the insn->imm with the function address (relative
to __bpf_call_base). If needed, the jit can find the btf_func_model
by calling the new bpf_jit_find_kfunc_model(prog, insn).
With the imm set to the function address, "bpftool prog dump xlated"
will be able to display the kernel function calls the same way as
it displays other bpf helper calls.
gpl_compatible program is required to call kernel function.
This feature currently requires JIT.
The verifier selftests are adjusted because of the changes in
the verbose log in add_subprog_and_kfunc().
Signed-off-by: Martin KaFai Lau <kafai@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20210325015142.1544736-1-kafai@fb.com
2021-03-25 04:51:42 +03:00
. errstr_unpriv = " loading/calling other bpf or kernel functions are allowed for " ,
2019-01-26 02:24:44 +03:00
. result_unpriv = REJECT ,
. result = ACCEPT ,
. retval = 2 ,
} ,
{
" dead code: start of a function " ,
. insns = {
BPF_MOV64_IMM ( BPF_REG_1 , 2 ) ,
BPF_RAW_INSN ( BPF_JMP | BPF_CALL , 0 , 1 , 0 , 1 ) ,
BPF_EXIT_INSN ( ) ,
BPF_JMP_IMM ( BPF_JA , 0 , 0 , 0 ) ,
BPF_MOV64_REG ( BPF_REG_0 , BPF_REG_1 ) ,
BPF_EXIT_INSN ( ) ,
} ,
bpf: Support bpf program calling kernel function
This patch adds support to BPF verifier to allow bpf program calling
kernel function directly.
The use case included in this set is to allow bpf-tcp-cc to directly
call some tcp-cc helper functions (e.g. "tcp_cong_avoid_ai()"). Those
functions have already been used by some kernel tcp-cc implementations.
This set will also allow the bpf-tcp-cc program to directly call the
kernel tcp-cc implementation, For example, a bpf_dctcp may only want to
implement its own dctcp_cwnd_event() and reuse other dctcp_*() directly
from the kernel tcp_dctcp.c instead of reimplementing (or
copy-and-pasting) them.
The tcp-cc kernel functions mentioned above will be white listed
for the struct_ops bpf-tcp-cc programs to use in a later patch.
The white listed functions are not bounded to a fixed ABI contract.
Those functions have already been used by the existing kernel tcp-cc.
If any of them has changed, both in-tree and out-of-tree kernel tcp-cc
implementations have to be changed. The same goes for the struct_ops
bpf-tcp-cc programs which have to be adjusted accordingly.
This patch is to make the required changes in the bpf verifier.
First change is in btf.c, it adds a case in "btf_check_func_arg_match()".
When the passed in "btf->kernel_btf == true", it means matching the
verifier regs' states with a kernel function. This will handle the
PTR_TO_BTF_ID reg. It also maps PTR_TO_SOCK_COMMON, PTR_TO_SOCKET,
and PTR_TO_TCP_SOCK to its kernel's btf_id.
In the later libbpf patch, the insn calling a kernel function will
look like:
insn->code == (BPF_JMP | BPF_CALL)
insn->src_reg == BPF_PSEUDO_KFUNC_CALL /* <- new in this patch */
insn->imm == func_btf_id /* btf_id of the running kernel */
[ For the future calling function-in-kernel-module support, an array
of module btf_fds can be passed at the load time and insn->off
can be used to index into this array. ]
At the early stage of verifier, the verifier will collect all kernel
function calls into "struct bpf_kfunc_desc". Those
descriptors are stored in "prog->aux->kfunc_tab" and will
be available to the JIT. Since this "add" operation is similar
to the current "add_subprog()" and looking for the same insn->code,
they are done together in the new "add_subprog_and_kfunc()".
In the "do_check()" stage, the new "check_kfunc_call()" is added
to verify the kernel function call instruction:
1. Ensure the kernel function can be used by a particular BPF_PROG_TYPE.
A new bpf_verifier_ops "check_kfunc_call" is added to do that.
The bpf-tcp-cc struct_ops program will implement this function in
a later patch.
2. Call "btf_check_kfunc_args_match()" to ensure the regs can be
used as the args of a kernel function.
3. Mark the regs' type, subreg_def, and zext_dst.
At the later do_misc_fixups() stage, the new fixup_kfunc_call()
will replace the insn->imm with the function address (relative
to __bpf_call_base). If needed, the jit can find the btf_func_model
by calling the new bpf_jit_find_kfunc_model(prog, insn).
With the imm set to the function address, "bpftool prog dump xlated"
will be able to display the kernel function calls the same way as
it displays other bpf helper calls.
gpl_compatible program is required to call kernel function.
This feature currently requires JIT.
The verifier selftests are adjusted because of the changes in
the verbose log in add_subprog_and_kfunc().
Signed-off-by: Martin KaFai Lau <kafai@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20210325015142.1544736-1-kafai@fb.com
2021-03-25 04:51:42 +03:00
. errstr_unpriv = " loading/calling other bpf or kernel functions are allowed for " ,
2019-01-26 02:24:44 +03:00
. result_unpriv = REJECT ,
. result = ACCEPT ,
. retval = 2 ,
} ,
2021-08-12 18:18:11 +03:00
{
" dead code: zero extension " ,
. insns = {
BPF_MOV64_IMM ( BPF_REG_0 , 0 ) ,
BPF_STX_MEM ( BPF_W , BPF_REG_10 , BPF_REG_0 , - 4 ) ,
BPF_JMP_IMM ( BPF_JGE , BPF_REG_0 , 0 , 1 ) ,
BPF_LDX_MEM ( BPF_W , BPF_REG_0 , BPF_REG_10 , - 4 ) ,
BPF_EXIT_INSN ( ) ,
} ,
. result = ACCEPT ,
. retval = 0 ,
} ,
