bpf: Allow invoking kfuncs from BPF_PROG_TYPE_SYSCALL progs
Subsystems (3)
PATCH 1/2 bpf: Allow invoking kfuncs from BPF_PROG_TYPE_SYSCALL progs
Currently, a set of core BPF kfuncs (e.g. bpf_task_*, bpf_cgroup_*, bpf_cpumask_*, etc) cannot be invoked from BPF_PROG_TYPE_SYSCALL programs. The whitelist approach taken for enabling kfuncs makes sense:
it not safe to call these kfuncs from every program type. For example, it may not be safe to call bpf_task_acquire() in an fentry to free_task().
BPF_PROG_TYPE_SYSCALL, on the other hand, is a perfectly safe program type from which to invoke these kfuncs, as it's a very controlled environment, and we should never be able to run into any of the typical problems such as recursive invoations, acquiring references on freeing kptrs, etc. Being able to invoke these kfuncs would be useful, as BPF_PROG_TYPE_SYSCALL can be invoked with BPF_PROG_RUN, and would therefore enable user space programs to synchronously call into BPF to manipulate these kptrs.
This patch therefore enables invoking the aforementioned core kfuncs from BPF_PROG_TYPE_SYSCALL progs.
--- kernel/bpf/cpumask.c | 1 + kernel/bpf/helpers.c | 1 + 2 files changed, 2 insertions(+)
kernel/bpf/cpumask.c +1 -0
@@ -474,6 +474,7 @@ static int __init cpumask_kfunc_init(void) ret =bpf_mem_alloc_init (&bpf_cpumask_ma,sizeof (struct bpf_cpumask ), false); ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_TRACING , &cpumask_kfunc_set); ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_STRUCT_OPS , &cpumask_kfunc_set); + ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_SYSCALL , &cpumask_kfunc_set);return ret ?:register_btf_id_dtor_kfuncs (cpumask_dtors,ARRAY_SIZE (cpumask_dtors),THIS_MODULE );
kernel/bpf/helpers.c +1 -0
@@ -2653,6 +2653,7 @@ static int __init kfunc_init(void) ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_SCHED_CLS , &generic_kfunc_set); ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_XDP , &generic_kfunc_set); ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_STRUCT_OPS , &generic_kfunc_set); + ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_SYSCALL , &generic_kfunc_set); ret = ret ?:register_btf_id_dtor_kfuncs (generic_dtors,ARRAY_SIZE (generic_dtors),THIS_MODULE );
Signature · 1 line
2.44.0
PATCH 2/2 selftests/bpf: Verify calling core kfuncs from BPF_PROG_TYPE_SYCALL
Now that we can call some kfuncs from BPF_PROG_TYPE_SYSCALL progs, let's add some selftests that verify as much. As a bonus, let's also verify that we can't call the progs from raw tracepoints.
--- .../selftests/bpf/prog_tests/cgrp_kfunc.c | 1 + .../selftests/bpf/prog_tests/task_kfunc.c | 1 + .../selftests/bpf/progs/cgrp_kfunc_common.h | 21 +++++++++++++++++++ .../selftests/bpf/progs/cgrp_kfunc_failure.c | 4 ++++ .../selftests/bpf/progs/cgrp_kfunc_success.c | 4 ++++ .../selftests/bpf/progs/cpumask_common.h | 19 +++++++++++++++++ .../selftests/bpf/progs/cpumask_failure.c | 4 ++++ .../selftests/bpf/progs/cpumask_success.c | 3 +++ .../selftests/bpf/progs/task_kfunc_common.h | 18 ++++++++++++++++ .../selftests/bpf/progs/task_kfunc_failure.c | 4 ++++ .../selftests/bpf/progs/task_kfunc_success.c | 4 ++++ 11 files changed, 83 insertions(+)
tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c +1 -0
@@ -102,6 +102,7 @@ void test_cgrp_kfunc(void)run_success_test (success_tests[i]); } +RUN_TESTS (cgrp_kfunc_success);RUN_TESTS (cgrp_kfunc_failure); cleanup:
tools/testing/selftests/bpf/prog_tests/task_kfunc.c +1 -0
@@ -94,5 +94,6 @@ void test_task_kfunc(void)run_success_test (success_tests[i]); } +RUN_TESTS (task_kfunc_success);RUN_TESTS (task_kfunc_failure); }
tools/testing/selftests/bpf/progs/cgrp_kfunc_common.h +21 -0
@@ -27,6 +27,27 @@ struct cgroup *bpf_cgroup_from_id(u64 cgid) __ksym; void bpf_rcu_read_lock(void) __ksym; void bpf_rcu_read_unlock(void) __ksym; +#define CGRP_KFUNC_LOAD_TEST (__name) \ +int BPF_PROG(cgroup_kfunc_load_test_##__name) \ +{ \ + struct cgroup *cgrp, *ref; \ + \ + cgrp = bpf_cgroup_from_id(0); \ + if (!cgrp) \ + return 0; \ + ref = bpf_cgroup_acquire(cgrp); \ + if (!ref) { \ + bpf_cgroup_release(cgrp); \ + return 0; \ + } \ + \ + bpf_cgroup_release(ref); \ + bpf_cgroup_release(cgrp); \ + \ + return 0; \ +} + +static inline struct __cgrps_kfunc_map_value *cgrps_kfunc_map_value_lookup (struct cgroup *cgrp) {s32 id;
tools/testing/selftests/bpf/progs/cgrp_kfunc_failure.c +4 -0
@@ -245,3 +245,7 @@ int BPF_PROG(cgrp_kfunc_release_unacquired, struct cgroup *cgrp, const char *patreturn 0 ; } + +SEC("raw_tp") +__failure __msg("calling kernel function") +CGRP_KFUNC_LOAD_TEST (raw_tp)
tools/testing/selftests/bpf/progs/cgrp_kfunc_success.c +4 -0
@@ -5,6 +5,7 @@#include <bpf/bpf_tracing.h> #include <bpf/bpf_helpers.h> +#include "bpf_misc.h" #include "cgrp_kfunc_common.h" char _license[] SEC("license") = "GPL";
@@ -221,3 +222,6 @@ int BPF_PROG(test_cgrp_from_id, struct cgroup *cgrp, const char *path)return 0 ; } + +SEC("syscall") __success +CGRP_KFUNC_LOAD_TEST (syscall )
tools/testing/selftests/bpf/progs/cpumask_common.h +19 -0
@@ -60,6 +60,25 @@ u32 bpf_cpumask_weight(const struct cpumask *cpumask) __ksym __weak; void bpf_rcu_read_lock(void) __ksym __weak; void bpf_rcu_read_unlock(void) __ksym __weak; +#define CPUMASK_KFUNC_LOAD_TEST (__name) \ +int BPF_PROG(cpumask_kfunc_load_test_##__name) \ +{ \ + struct bpf_cpumask *alloc, *ref; \ + \ + alloc = bpf_cpumask_create(); \ + if (!alloc) \ + return 0; \ + \ + ref = bpf_cpumask_acquire(alloc); \ + if (ref) \ + bpf_cpumask_release(ref); \ + bpf_cpumask_set_cpu(0, alloc); \ + bpf_cpumask_test_cpu(0, (const struct cpumask *)alloc); \ + bpf_cpumask_release(alloc); \ + \ + return 0; \ +} +static inline const struct cpumask *cast (struct bpf_cpumask *cpumask) {return (const struct cpumask *)cpumask;
tools/testing/selftests/bpf/progs/cpumask_failure.c +4 -0
@@ -190,3 +190,7 @@ int BPF_PROG(test_global_mask_rcu_no_null_check, struct task_struct *task, u64 creturn 0 ; } + +SEC("raw_tp") +__failure __msg("calling kernel function") +CPUMASK_KFUNC_LOAD_TEST (raw_tp)
tools/testing/selftests/bpf/progs/cpumask_success.c +3 -0
@@ -525,3 +525,6 @@ int BPF_PROG(test_refcount_null_tracking, struct task_struct *task, u64 clone_flbpf_cpumask_release (mask2);return 0 ; } + +SEC("syscall") __success +CPUMASK_KFUNC_LOAD_TEST (syscall )
tools/testing/selftests/bpf/progs/task_kfunc_common.h +18 -0
@@ -26,6 +26,24 @@ struct task_struct *bpf_task_from_pid(s32 pid) __ksym; void bpf_rcu_read_lock(void) __ksym; void bpf_rcu_read_unlock(void) __ksym; +#define TASK_KFUNC_LOAD_TEST (__name) \ +int BPF_PROG(task_kfunc_load_test_##__name) \ +{ \ + struct task_struct *current, *ref_1, *ref_2; \ + \ + current = bpf_get_current_task_btf(); \ + ref_1 = bpf_task_from_pid(current->pid); \ + if (!ref_1) \ + return 0; \ + \ + ref_2 = bpf_task_acquire(ref_1); \ + if (ref_2) \ + bpf_task_release(ref_2); \ + bpf_task_release(ref_1); \ + \ + return 0; \ +} +static inline struct __tasks_kfunc_map_value *tasks_kfunc_map_value_lookup (struct task_struct *p) {s32 pid;
tools/testing/selftests/bpf/progs/task_kfunc_failure.c +4 -0
@@ -324,3 +324,7 @@ int BPF_PROG(task_kfunc_release_in_map, struct task_struct *task, u64 clone_flagreturn 0 ; } + +SEC("raw_tp") +__failure __msg("calling kernel function") +TASK_KFUNC_LOAD_TEST (raw_tp)
tools/testing/selftests/bpf/progs/task_kfunc_success.c +4 -0
@@ -5,6 +5,7 @@#include <bpf/bpf_tracing.h> #include <bpf/bpf_helpers.h> +#include "bpf_misc.h" #include "task_kfunc_common.h" char _license[] SEC("license") = "GPL";
@@ -314,3 +315,6 @@ int BPF_PROG(task_kfunc_acquire_trusted_walked, struct task_struct *task, u64 clreturn 0 ; } + +SEC("syscall") __success +TASK_KFUNC_LOAD_TEST (syscall )
Signature · 1 line
2.44.0
A message that is not in the archive (sent off-list or not yet received): [email protected]
Re: [PATCH bpf-next 2/2] selftests/bpf: Verify calling core kfuncs from BPF_PROG_TYPE_SYCALL
Quoted 11 lines · Yonghong Song
Quoted 5 lines · David Vernet
Now that we can call some kfuncs from
BPF_PROG_TYPE_SYSCALLprogs, let's add some selftests that verify as much. As a bonus, let's also verify that we can't call the progs from raw tracepoints.Signed-off-by David Vernet <[email protected]>Ack with some comments below.
Acked-by Yonghong Song <[email protected]>
Thanks for the review. It looks like accidentally replied directly to me, so I'll re-add the missing cc's.
Quoted 36 lines
Quoted 30 lines
--- .../selftests/bpf/prog_tests/cgrp_kfunc.c | 1 + .../selftests/bpf/prog_tests/task_kfunc.c | 1 + .../selftests/bpf/progs/cgrp_kfunc_common.h | 21 +++++++++++++++++++ .../selftests/bpf/progs/cgrp_kfunc_failure.c | 4 ++++ .../selftests/bpf/progs/cgrp_kfunc_success.c | 4 ++++ .../selftests/bpf/progs/cpumask_common.h | 19 +++++++++++++++++ .../selftests/bpf/progs/cpumask_failure.c | 4 ++++ .../selftests/bpf/progs/cpumask_success.c | 3 +++ .../selftests/bpf/progs/task_kfunc_common.h | 18 ++++++++++++++++ .../selftests/bpf/progs/task_kfunc_failure.c | 4 ++++ .../selftests/bpf/progs/task_kfunc_success.c | 4 ++++ 11 files changed, 83 insertions(+)tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c +1
-0@@ -102,6 +102,7 @@ void test_cgrp_kfunc(void)run_success_test (success_tests[i]); } +RUN_TESTS (cgrp_kfunc_success);RUN_TESTS (cgrp_kfunc_failure); cleanup:tools/testing/selftests/bpf/prog_tests/task_kfunc.c +0
-0tools/testing/selftests/bpf/prog_tests/task_kfunc.c void test_task_kfunc(void) · line 98
Quoted 5 lines
tools/testing/selftests/bpf/prog_tests/task_kfunc.c +1
-0@@ -94,5 +94,6 @@ void test_task_kfunc(void)run_success_test (success_tests[i]); } +RUN_TESTS (task_kfunc_success);RUN_TESTS (task_kfunc_failure); }
Quoted 7 lines
The above
RUN_TESTS(cgrp_kfunc_success)andRUN_TESTS(task_kfunc_success)will do duplicate work for *existing* bpf programs in their respective files. I think we still prefer to havecgrp_kfunc_successtests incgrp_kfunc.cto make it easy to cross check. But in order to remove duplicate work, one option is to make other non-RUN_TESTS programs in those files not auto-loaded and their corresponding prog_tests/*.c file need to explicitly enable loading the problem.
Good point, and yes I agree with that approach of not auto-loading non-RUN_TESTS programs. Considering that we have a __success BTF tag to say, "this prog should successfully load", it seems odd that we'd also automatically load and validate progs that _didn't_ specify that tag as well. At that point, I'm not sure what value the tag is bringing. Also, that was the expected behavior before RUN_TESTS() was introduced, so it hopefully shouldn't cause much if any churn.
Quoted 2 lines
Maybe the current patch is okay even with duplicated work as it should not take much time to verify those tiny problems.
IMO it should be fine for now as the overhead for validating and loading these progs is low, but it'd definitely be good to address this problem in a follow-up. I don't think it should take too much effort -- AFAICT we'd just have to mark a test spec as invalid if it didn't have any BTF test tags. Ideally I'd like to separate that from this patch set, but I can do it here if folks want.
Thanks,
David
Yonghong Song
reviewerRe: [PATCH bpf-next 2/2] selftests/bpf: Verify calling core kfuncs from BPF_PROG_TYPE_SYCALL
Quoted 62 lines · David Vernet
Quoted 9 lines · Yonghong Song
Quoted 5 lines · David Vernet
Now that we can call some kfuncs from
BPF_PROG_TYPE_SYSCALLprogs, let's add some selftests that verify as much. As a bonus, let's also verify that we can't call the progs from raw tracepoints.Signed-off-by David Vernet <[email protected]>Ack with some comments below.
Acked-by Yonghong Song <[email protected]>Thanks for the review. It looks like accidentally replied directly to me, so I'll re-add the missing cc's.
Quoted 33 lines
Quoted 33 lines
--- .../selftests/bpf/prog_tests/cgrp_kfunc.c | 1 + .../selftests/bpf/prog_tests/task_kfunc.c | 1 + .../selftests/bpf/progs/cgrp_kfunc_common.h | 21 +++++++++++++++++++ .../selftests/bpf/progs/cgrp_kfunc_failure.c | 4 ++++ .../selftests/bpf/progs/cgrp_kfunc_success.c | 4 ++++ .../selftests/bpf/progs/cpumask_common.h | 19 +++++++++++++++++ .../selftests/bpf/progs/cpumask_failure.c | 4 ++++ .../selftests/bpf/progs/cpumask_success.c | 3 +++ .../selftests/bpf/progs/task_kfunc_common.h | 18 ++++++++++++++++ .../selftests/bpf/progs/task_kfunc_failure.c | 4 ++++ .../selftests/bpf/progs/task_kfunc_success.c | 4 ++++ 11 files changed, 83 insertions(+)tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c +1
-0@@ -102,6 +102,7 @@ void test_cgrp_kfunc(void)run_success_test (success_tests[i]); } +RUN_TESTS (cgrp_kfunc_success);RUN_TESTS (cgrp_kfunc_failure); cleanup:tools/testing/selftests/bpf/prog_tests/task_kfunc.c +1
-0@@ -94,5 +94,6 @@ void test_task_kfunc(void)run_success_test (success_tests[i]); } +RUN_TESTS (task_kfunc_success);RUN_TESTS (task_kfunc_failure);Quoted 8 lines
tools/testing/selftests/bpf/prog_tests/task_kfunc.c void test_task_kfunc(void) · line 98
Quoted 1 line
tools/testing/selftests/bpf/prog_tests/task_kfunc.c +0
-0}The above
RUN_TESTS(cgrp_kfunc_success)andRUN_TESTS(task_kfunc_success)will do duplicate work for *existing* bpf programs in their respective files. I think we still prefer to havecgrp_kfunc_successtests incgrp_kfunc.cto make it easy to cross check. But in order to remove duplicate work, one option is to make other non-RUN_TESTS programs in those files not auto-loaded and their corresponding prog_tests/*.c file need to explicitly enable loading the problem.Good point, and yes I agree with that approach of not auto-loading non-RUN_TESTS programs. Considering that we have a
__successBTF tag to say, "this prog should successfully load", it seems odd that we'd also automatically load and validate progs that _didn't_ specify that tag as well. At that point, I'm not sure what value the tag is bringing. Also, that was the expected behavior beforeRUN_TESTS()was introduced, so it hopefully shouldn't cause much if any churn.
Quoted 8 lines
Quoted 2 lines
Maybe the current patch is okay even with duplicated work as it should not take much time to verify those tiny problems.
IMO it should be fine for now as the overhead for validating and loading these progs is low, but it'd definitely be good to address this problem in a follow-up. I don't think it should take too much effort -- AFAICT we'd just have to mark a test spec as invalid if it didn't have any BTF test tags. Ideally I'd like to separate that from this patch set, but I can do it here if folks want.
Or you can remove __success from cgrp_kfunc_success.c, cpumask_success.c and task_kfunc_success.c and also remove their corresponding RUN_TESTS(cgrp_kfunc_success) and RUN_TESTS(task_kfunc_success). For example, you do not have RUN_TESTS(cpumask_success) and it is okay.
Basically, those expect-to-succeed new programs should be verified already even without RUN_TESTS.
Quoted 3 lines
Thanks,
David
Re: [PATCH bpf-next 2/2] selftests/bpf: Verify calling core kfuncs from BPF_PROG_TYPE_SYCALL
In reply to David VernetQuoted 8 lines · David Vernet
Quoted 6 lines · Yonghong Song
Quoted 4 lines · David Vernet
Now that we can call some kfuncs from
BPF_PROG_TYPE_SYSCALLprogs, let's add some selftests that verify as much. As a bonus, let's also verify that we can't call the progs from raw tracepoints.
Quoted 9 lines
Quoted 5 lines
Quoted 1 line
Signed-off-by David Vernet <[email protected]>Ack with some comments below.
Acked-by Yonghong Song <[email protected]>Thanks for the review. It looks like accidentally replied directly to me, so I'll re-add the missing cc's.
And dropped bpf@vger :) adding back
Quoted 44 lines
Quoted 36 lines
Quoted 30 lines
--- .../selftests/bpf/prog_tests/cgrp_kfunc.c | 1 + .../selftests/bpf/prog_tests/task_kfunc.c | 1 + .../selftests/bpf/progs/cgrp_kfunc_common.h | 21 +++++++++++++++++++ .../selftests/bpf/progs/cgrp_kfunc_failure.c | 4 ++++ .../selftests/bpf/progs/cgrp_kfunc_success.c | 4 ++++ .../selftests/bpf/progs/cpumask_common.h | 19 +++++++++++++++++ .../selftests/bpf/progs/cpumask_failure.c | 4 ++++ .../selftests/bpf/progs/cpumask_success.c | 3 +++ .../selftests/bpf/progs/task_kfunc_common.h | 18 ++++++++++++++++ .../selftests/bpf/progs/task_kfunc_failure.c | 4 ++++ .../selftests/bpf/progs/task_kfunc_success.c | 4 ++++ 11 files changed, 83 insertions(+)tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c +1
-0@@ -102,6 +102,7 @@ void test_cgrp_kfunc(void)run_success_test (success_tests[i]); } +RUN_TESTS (cgrp_kfunc_success);RUN_TESTS (cgrp_kfunc_failure); cleanup:tools/testing/selftests/bpf/prog_tests/task_kfunc.c +0
-0tools/testing/selftests/bpf/prog_tests/task_kfunc.c void test_task_kfunc(void) · line 98
Quoted 5 lines
tools/testing/selftests/bpf/prog_tests/task_kfunc.c +1
-0@@ -94,5 +94,6 @@ void test_task_kfunc(void)run_success_test (success_tests[i]); } +RUN_TESTS (task_kfunc_success);RUN_TESTS (task_kfunc_failure); }Quoted 7 lines
The above
RUN_TESTS(cgrp_kfunc_success)andRUN_TESTS(task_kfunc_success)will do duplicate work for *existing* bpf programs in their respective files. I think we still prefer to havecgrp_kfunc_successtests incgrp_kfunc.cto make it easy to cross check. But in order to remove duplicate work, one option is to make other non-RUN_TESTS programs in those files not auto-loaded and their corresponding prog_tests/*.c file need to explicitly enable loading the problem.
Quoted 5 lines
Good point, and yes I agree with that approach of not auto-loading non-RUN_TESTS programs. Considering that we have a
__successBTF tag to say, "this prog should successfully load", it seems odd that we'd also automatically load and validate progs that _didn't_ specify that tag as well. At that point, I'm not sure what value the tag is bringing. Also,
Just more explicitness (if desired). Normally __success would be augmented by __msg() or __retval(). I'd feel uncomfortable just silently skipping programs that are not marked with __success, as it would be too easy to accidentally forget to add it and not know that the BPF program is not tested.
I'd say that RUN_TESTS-based programs should be kept separate from any other BPF programs that have a custom user-space testing part, though.
About the patch itself. I don't really see much point in adding *_KFUNC_LOAD_TEST macros. They are used once or twice in total, while obscuring *what* is actually being tested. Unless you expect to add 5+ more copies of them, I'd just inline them explicitly.
Quoted 15 lines
that was the expected behavior before
RUN_TESTS()was introduced, so it hopefully shouldn't cause much if any churn.Quoted 2 lines
Maybe the current patch is okay even with duplicated work as it should not take much time to verify those tiny problems.
IMO it should be fine for now as the overhead for validating and loading these progs is low, but it'd definitely be good to address this problem in a follow-up. I don't think it should take too much effort -- AFAICT we'd just have to mark a test spec as invalid if it didn't have any BTF test tags. Ideally I'd like to separate that from this patch set, but I can do it here if folks want.
Thanks,
David
Re: [PATCH bpf-next 2/2] selftests/bpf: Verify calling core kfuncs from BPF_PROG_TYPE_SYCALL
Quoted 13 lines · Andrii Nakryiko
Quoted 12 lines · David Vernet
Quoted 10 lines · Yonghong Song
Quoted 5 lines · David Vernet
Now that we can call some kfuncs from
BPF_PROG_TYPE_SYSCALLprogs, let's add some selftests that verify as much. As a bonus, let's also verify that we can't call the progs from raw tracepoints.Signed-off-by David Vernet <[email protected]>Ack with some comments below.
Quoted 7 lines
Quoted 5 lines
Quoted 1 line
Acked-by Yonghong Song <[email protected]>Thanks for the review. It looks like accidentally replied directly to me, so I'll re-add the missing cc's.
And dropped bpf@vger :) adding back
*facepalm*, thanks!
Quoted 45 lines
Quoted 45 lines
Quoted 44 lines
Quoted 31 lines
--- .../selftests/bpf/prog_tests/cgrp_kfunc.c | 1 + .../selftests/bpf/prog_tests/task_kfunc.c | 1 + .../selftests/bpf/progs/cgrp_kfunc_common.h | 21 +++++++++++++++++++ .../selftests/bpf/progs/cgrp_kfunc_failure.c | 4 ++++ .../selftests/bpf/progs/cgrp_kfunc_success.c | 4 ++++ .../selftests/bpf/progs/cpumask_common.h | 19 +++++++++++++++++ .../selftests/bpf/progs/cpumask_failure.c | 4 ++++ .../selftests/bpf/progs/cpumask_success.c | 3 +++ .../selftests/bpf/progs/task_kfunc_common.h | 18 ++++++++++++++++ .../selftests/bpf/progs/task_kfunc_failure.c | 4 ++++ .../selftests/bpf/progs/task_kfunc_success.c | 4 ++++ 11 files changed, 83 insertions(+)tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c +1
-0@@ -102,6 +102,7 @@ void test_cgrp_kfunc(void)run_success_test (success_tests[i]); } +RUN_TESTS (cgrp_kfunc_success);RUN_TESTS (cgrp_kfunc_failure); cleanup:tools/testing/selftests/bpf/prog_tests/task_kfunc.c +0
-0tools/testing/selftests/bpf/prog_tests/task_kfunc.c void test_task_kfunc(void) · line 98
Quoted 5 lines
tools/testing/selftests/bpf/prog_tests/task_kfunc.c +1
-0@@ -94,5 +94,6 @@ void test_task_kfunc(void)run_success_test (success_tests[i]); } +RUN_TESTS (task_kfunc_success);RUN_TESTS (task_kfunc_failure); }The above
RUN_TESTS(cgrp_kfunc_success)andRUN_TESTS(task_kfunc_success)will do duplicate work for *existing* bpf programs in their respective files. I think we still prefer to havecgrp_kfunc_successtests incgrp_kfunc.cto make it easy to cross check. But in order to remove duplicate work, one option is to make other non-RUN_TESTS programs in those files not auto-loaded and their corresponding prog_tests/*.c file need to explicitly enable loading the problem.
Quoted 8 lines
Quoted 5 lines
Good point, and yes I agree with that approach of not auto-loading non-RUN_TESTS programs. Considering that we have a
__successBTF tag to say, "this prog should successfully load", it seems odd that we'd also automatically load and validate progs that _didn't_ specify that tag as well. At that point, I'm not sure what value the tag is bringing. Also,Just more explicitness (if desired). Normally
__successwould be augmented by__msg()or__retval(). I'd feel uncomfortable just
But __success really has no actual purpose, right? Isn't it identical to if it's just left off? You don't need __success to specify __msg() or __retval() right?
Quoted 6 lines
silently skipping programs that are not marked with
__success, as it would be too easy to accidentally forget to add it and not know that the BPF program is not tested.I'd say that RUN_TESTS-based programs should be kept separate from any other BPF programs that have a custom user-space testing part, though.
IF we do go this way, maybe just a __skip or something tag would be sufficient?
Quoted 4 lines
About the patch itself. I don't really see much point in adding
*_KFUNC_LOAD_TESTmacros. They are used once or twice in total, while obscuring *what* is actually being tested. Unless you expect to add 5+ more copies of them, I'd just inline them explicitly.
It's not really important what's in the actual prog though -- the point is that we're verifying we can invoke some kfuncs in a certain prog type. But yes, it does obscure what's there, and I'm fine with copy-pasting them if that's your preference. The reason I went with a macro was to make it easy for us to quickly test new prog types as we add support for them, or to add other negative testcases for unsafe prog types. Right now we're just testing tracing progs.
Quoted 16 lines
Quoted 16 lines
that was the expected behavior before
RUN_TESTS()was introduced, so it hopefully shouldn't cause much if any churn.Quoted 2 lines
Maybe the current patch is okay even with duplicated work as it should not take much time to verify those tiny problems.
IMO it should be fine for now as the overhead for validating and loading these progs is low, but it'd definitely be good to address this problem in a follow-up. I don't think it should take too much effort -- AFAICT we'd just have to mark a test spec as invalid if it didn't have any BTF test tags. Ideally I'd like to separate that from this patch set, but I can do it here if folks want.
Thanks,
David
Re: [PATCH bpf-next 2/2] selftests/bpf: Verify calling core kfuncs from BPF_PROG_TYPE_SYCALL
Quoted 76 lines · David Vernet
Quoted 13 lines · Andrii Nakryiko
Quoted 12 lines · David Vernet
Quoted 10 lines · Yonghong Song
Quoted 5 lines · David Vernet
Now that we can call some kfuncs from
BPF_PROG_TYPE_SYSCALLprogs, let's add some selftests that verify as much. As a bonus, let's also verify that we can't call the progs from raw tracepoints.Signed-off-by David Vernet <[email protected]>Ack with some comments below.
Quoted 7 lines
Quoted 5 lines
Quoted 1 line
Acked-by Yonghong Song <[email protected]>Thanks for the review. It looks like accidentally replied directly to me, so I'll re-add the missing cc's.
And dropped bpf@vger :) adding back
*facepalm*, thanks!
Quoted 51 lines
Quoted 50 lines
Quoted 37 lines
Quoted 31 lines
--- .../selftests/bpf/prog_tests/cgrp_kfunc.c | 1 + .../selftests/bpf/prog_tests/task_kfunc.c | 1 + .../selftests/bpf/progs/cgrp_kfunc_common.h | 21 +++++++++++++++++++ .../selftests/bpf/progs/cgrp_kfunc_failure.c | 4 ++++ .../selftests/bpf/progs/cgrp_kfunc_success.c | 4 ++++ .../selftests/bpf/progs/cpumask_common.h | 19 +++++++++++++++++ .../selftests/bpf/progs/cpumask_failure.c | 4 ++++ .../selftests/bpf/progs/cpumask_success.c | 3 +++ .../selftests/bpf/progs/task_kfunc_common.h | 18 ++++++++++++++++ .../selftests/bpf/progs/task_kfunc_failure.c | 4 ++++ .../selftests/bpf/progs/task_kfunc_success.c | 4 ++++ 11 files changed, 83 insertions(+)tools/testing/selftests/bpf/prog_tests/cgrp_kfunc.c +1
-0@@ -102,6 +102,7 @@ void test_cgrp_kfunc(void)run_success_test (success_tests[i]); } +RUN_TESTS (cgrp_kfunc_success);RUN_TESTS (cgrp_kfunc_failure); cleanup:tools/testing/selftests/bpf/prog_tests/task_kfunc.c +0
-0tools/testing/selftests/bpf/prog_tests/task_kfunc.c void test_task_kfunc(void) · line 98
Quoted 5 lines
tools/testing/selftests/bpf/prog_tests/task_kfunc.c +1
-0@@ -94,5 +94,6 @@ void test_task_kfunc(void)run_success_test (success_tests[i]); } +RUN_TESTS (task_kfunc_success);RUN_TESTS (task_kfunc_failure); }Quoted 7 lines
The above
RUN_TESTS(cgrp_kfunc_success)andRUN_TESTS(task_kfunc_success)will do duplicate work for *existing* bpf programs in their respective files. I think we still prefer to havecgrp_kfunc_successtests incgrp_kfunc.cto make it easy to cross check. But in order to remove duplicate work, one option is to make other non-RUN_TESTS programs in those files not auto-loaded and their corresponding prog_tests/*.c file need to explicitly enable loading the problem.Good point, and yes I agree with that approach of not auto-loading non-RUN_TESTS programs. Considering that we have a
__successBTF tag to say, "this prog should successfully load", it seems odd that we'd also automatically load and validate progs that _didn't_ specify that tag as well. At that point, I'm not sure what value the tag is bringing. Also,
Quoted 6 lines
Quoted 2 lines
Just more explicitness (if desired). Normally
__successwould be augmented by__msg()or__retval(). I'd feel uncomfortable justBut
__successreally has no actual purpose, right? Isn't it identical to if it's just left off? You don't need__successto specify__msg()or__retval()right?
right, it's just a more explicit documentation-like annotation, if you will
Quoted 10 lines
Quoted 7 lines
silently skipping programs that are not marked with
__success, as it would be too easy to accidentally forget to add it and not know that the BPF program is not tested.I'd say that RUN_TESTS-based programs should be kept separate from any other BPF programs that have a custom user-space testing part, though.
IF we do go this way, maybe just a
__skipor something tag would be sufficient?
if we go this way we wouldn't need __skip, but if we do not go, then sure, why not. But in general, __skip makes sense either way, I guess, I have no problem with it.
Quoted 6 lines
Quoted 5 lines
About the patch itself. I don't really see much point in adding
*_KFUNC_LOAD_TESTmacros. They are used once or twice in total, while obscuring *what* is actually being tested. Unless you expect to add 5+ more copies of them, I'd just inline them explicitly.
Quoted 7 lines
It's not really important what's in the actual prog though -- the point is that we're verifying we can invoke some kfuncs in a certain prog type. But yes, it does obscure what's there, and I'm fine with copy-pasting them if that's your preference. The reason I went with a macro was to make it easy for us to quickly test new prog types as we add support for them, or to add other negative testcases for unsafe prog types. Right now we're just testing tracing progs.
I'm always for less macro usage, if possible :)
For the use case you are describing I'd just add static subprog that exercises all the kfuncs of interest, and then call this subprog from all the (explicitly defined) main entry program of desired program types
Quoted 17 lines
Quoted 17 lines
Quoted 17 lines
that was the expected behavior before
RUN_TESTS()was introduced, so it hopefully shouldn't cause much if any churn.Quoted 2 lines
Maybe the current patch is okay even with duplicated work as it should not take much time to verify those tiny problems.
IMO it should be fine for now as the overhead for validating and loading these progs is low, but it'd definitely be good to address this problem in a follow-up. I don't think it should take too much effort -- AFAICT we'd just have to mark a test spec as invalid if it didn't have any BTF test tags. Ideally I'd like to separate that from this patch set, but I can do it here if folks want.
Thanks,
David
Re: [PATCH bpf-next 2/2] selftests/bpf: Verify calling core kfuncs from BPF_PROG_TYPE_SYCALL
On Thu, Apr 04, 2024 at 03:35:32PM -0700, Andrii Nakryiko wrote:
[...]
Quoted 31 lines
Quoted 14 lines
Quoted 14 lines
Quoted 13 lines
Quoted 7 lines
The above
RUN_TESTS(cgrp_kfunc_success)andRUN_TESTS(task_kfunc_success)will do duplicate work for *existing* bpf programs in their respective files. I think we still prefer to havecgrp_kfunc_successtests incgrp_kfunc.cto make it easy to cross check. But in order to remove duplicate work, one option is to make other non-RUN_TESTS programs in those files not auto-loaded and their corresponding prog_tests/*.c file need to explicitly enable loading the problem.Good point, and yes I agree with that approach of not auto-loading non-RUN_TESTS programs. Considering that we have a
__successBTF tag to say, "this prog should successfully load", it seems odd that we'd also automatically load and validate progs that _didn't_ specify that tag as well. At that point, I'm not sure what value the tag is bringing. Also,Quoted 6 lines
Quoted 2 lines
Just more explicitness (if desired). Normally
__successwould be augmented by__msg()or__retval(). I'd feel uncomfortable justBut
__successreally has no actual purpose, right? Isn't it identical to if it's just left off? You don't need__successto specify__msg()or__retval()right?right, it's just a more explicit documentation-like annotation, if you will
Quoted 8 lines
Quoted 7 lines
silently skipping programs that are not marked with
__success, as it would be too easy to accidentally forget to add it and not know that the BPF program is not tested.I'd say that RUN_TESTS-based programs should be kept separate from any other BPF programs that have a custom user-space testing part, though.
Quoted 6 lines
Quoted 2 lines
IF we do go this way, maybe just a
__skipor something tag would be sufficient?if we go this way we wouldn't need
__skip, but if we do not go, then sure, why not. But in general,__skipmakes sense either way, I guess, I have no problem with it.
Sorry, by "if we go this way" what I meant was "if we continue to have RUN_TESTS() run all progs by default." Given that we're doing that, it sounds like we're on the same page page and that __skip is the way to go.
Quoted 15 lines
Quoted 7 lines
Quoted 6 lines
About the patch itself. I don't really see much point in adding
*_KFUNC_LOAD_TESTmacros. They are used once or twice in total, while obscuring *what* is actually being tested. Unless you expect to add 5+ more copies of them, I'd just inline them explicitly.Quoted 7 lines
It's not really important what's in the actual prog though -- the point is that we're verifying we can invoke some kfuncs in a certain prog type. But yes, it does obscure what's there, and I'm fine with copy-pasting them if that's your preference. The reason I went with a macro was to make it easy for us to quickly test new prog types as we add support for them, or to add other negative testcases for unsafe prog types. Right now we're just testing tracing progs.
Quoted 6 lines
I'm always for less macro usage, if possible :)
For the use case you are describing I'd just add static subprog that exercises all the kfuncs of interest, and then call this subprog from all the (explicitly defined) main entry program of desired program types
Will do for v2. Thanks!
Quoted 16 lines · David Vernet
Currently, a set of core BPF kfuncs (e.g. bpf_task_*, bpf_cgroup_*, bpf_cpumask_*, etc) cannot be invoked from
BPF_PROG_TYPE_SYSCALLprograms. The whitelist approach taken for enabling kfuncs makes sense:
it not safe to call these kfuncs from every program type. For example, it may not be safe to callbpf_task_acquire()in an fentry tofree_task().
BPF_PROG_TYPE_SYSCALL, on the other hand, is a perfectly safe program type from which to invoke these kfuncs, as it's a very controlled environment, and we should never be able to run into any of the typical problems such as recursive invoations, acquiring references on freeing kptrs, etc. Being able to invoke these kfuncs would be useful, asBPF_PROG_TYPE_SYSCALLcan be invoked withBPF_PROG_RUN, and would therefore enable user space programs to synchronously call into BPF to manipulate these kptrs.
Quoted 4 lines
This patch therefore enables invoking the aforementioned core kfuncs from
BPF_PROG_TYPE_SYSCALLprogs.Signed-off-by David Vernet <[email protected]>
Quoted 17 lines · David Vernet
Currently, a set of core BPF kfuncs (e.g. bpf_task_*, bpf_cgroup_*, bpf_cpumask_*, etc) cannot be invoked from
BPF_PROG_TYPE_SYSCALLprograms. The whitelist approach taken for enabling kfuncs makes sense:
it not safe to call these kfuncs from every program type. For example, it may not be safe to callbpf_task_acquire()in an fentry tofree_task().
BPF_PROG_TYPE_SYSCALL, on the other hand, is a perfectly safe program type from which to invoke these kfuncs, as it's a very controlled environment, and we should never be able to run into any of the typical problems such as recursive invoations, acquiring references on freeing kptrs, etc. Being able to invoke these kfuncs would be useful, asBPF_PROG_TYPE_SYSCALLcan be invoked withBPF_PROG_RUN, and would therefore enable user space programs to synchronously call into BPF to manipulate these kptrs.
Quoted 9 lines
This patch therefore enables invoking the aforementioned core kfuncs from
BPF_PROG_TYPE_SYSCALLprogs.Signed-off-by David Vernet <[email protected]>--- kernel/bpf/cpumask.c | 1 + kernel/bpf/helpers.c | 1 + 2 files changed, 2 insertions(+)
Makes sense, but see my comments on patch #2.
Quoted 27 lines
kernel/bpf/cpumask.c +1
-0@@ -474,6 +474,7 @@ static int __init cpumask_kfunc_init(void) ret =bpf_mem_alloc_init (&bpf_cpumask_ma,sizeof (struct bpf_cpumask ), false); ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_TRACING , &cpumask_kfunc_set); ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_STRUCT_OPS , &cpumask_kfunc_set); + ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_SYSCALL , &cpumask_kfunc_set);return ret ?:register_btf_id_dtor_kfuncs (cpumask_dtors,ARRAY_SIZE (cpumask_dtors),THIS_MODULE );kernel/bpf/helpers.c +1
-1@@ -2653,6 +2653,7 @@ static int __init kfunc_init(void) ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_SCHED_CLS , &generic_kfunc_set); ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_XDP , &generic_kfunc_set); ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_STRUCT_OPS , &generic_kfunc_set); + ret = ret ?:register_btf_kfunc_id_set (BPF_PROG_TYPE_SYSCALL , &generic_kfunc_set); ret = ret ?:register_btf_id_dtor_kfuncs (generic_dtors,ARRAY_SIZE (generic_dtors),THIS_MODULE ); --2.44.0