bpf: Fix tailcall infinite loop caused by freplace
Subsystems (4)
v6 cover bpf: Fix tailcall infinite loop caused by freplace
Previously, I fixed a tailcall infinite loop issue caused by trampoline[0].
At this time, I fix a tailcall infinite loop issue caused by tailcall and freplace combination by preventing updating extended prog to prog_array map and preventing extending tail callee prog with freplace:
1. If a prog or its subprog has been extended by freplace prog, the prog can not be updated to prog_array map.
2. If a prog has been updated to prog_array map, it or its subprog can not be extended by freplace prog.
Changes:
v5 -> v6:
* Fix a build warning reported by kernel test robot.
v4 -> v5:
* Move code of linking/unlinking target prog of freplace to trampoline.c.
* Address comments from Alexei:
* Change type of prog_array_member_cnt to u64.
* Combine two patches to one.
v3 -> v4:
* Address comments from Eduard:
* Rename 'tail_callee_cnt' to 'prog_array_member_cnt'.
* Add comment to 'prog_array_member_cnt'.
* Use a mutex to protect 'is_extended' and 'prog_array_member_cnt'.
v2 -> v3:
* Address comments from Alexei:
* Stop hacking JIT.
* Prevent the specific use case at attach/update time.
v1 -> v2:
* Address comment from Eduard:
* Explain why nop5 and xor/nop3 are swapped at prologue.
* Address comment from Alexei:
* Disallow attaching tail_call_reachable freplace prog to not-tail_call_reachable target in verifier.
* Update "bpf, arm64: Fix tailcall infinite loop caused by freplace" with latest arm64 JIT code.
Links:
[0] https://lore.kernel.org/bpf/[email protected]/
Leon Hwang (3):
bpf: Prevent tailcall infinite loop caused by freplace selftests/bpf: Add a test case to confirm a tailcall infinite loop
issue has been prevented
selftests/bpf: Add cases to test tailcall in freplace
include/linux/bpf.h | 21 ++ kernel/bpf/arraymap.c | 23 +- kernel/bpf/core.c | 1 + kernel/bpf/syscall.c | 21 +- kernel/bpf/trampoline.c | 43 ++++ .../selftests/bpf/prog_tests/tailcalls.c | 196 +++++++++++++++++- .../tailcall_bpf2bpf_hierarchy_freplace.c | 30 +++ .../testing/selftests/bpf/progs/tc_bpf2bpf.c | 37 +++- 8 files changed, 361 insertions(+), 11 deletions(-) create mode 100644 tools/testing/selftests/bpf/progs/tailcall_bpf2bpf_hierarchy_freplace.c
Signature · 1 line
2.44.0
PATCH v6 1/3 bpf: Prevent tailcall infinite loop caused by freplace
This patch prevents an infinite loop issue caused by combination of tailcall and freplace.
For example:
tc_bpf2bpf.c:
// SPDX-License-Identifier: GPL-2.0
\#include <linux/bpf.h>
\#include <bpf/bpf_helpers.h>
__noinline
int subprog_tc(struct __sk_buff *skb)
{
return skb->len * 2;
}SEC("tc")
int entry_tc(struct __sk_buff *skb)
{
return subprog_tc(skb);
}char __license[] SEC("license") = "GPL";
tailcall_freplace.c:
// SPDX-License-Identifier: GPL-2.0
\#include <linux/bpf.h>
\#include <bpf/bpf_helpers.h>
struct {
__uint(type, BPF_MAP_TYPE_PROG_ARRAY);
__uint(max_entries, 1);
__uint(key_size, sizeof(__u32));
__uint(value_size, sizeof(__u32));
} jmp_table SEC(".maps");int count = 0;
SEC("freplace")
int entry_freplace(struct __sk_buff *skb)
{
count++;
bpf_tail_call_static(skb, &jmp_table, 0);
return count;
}char __license[] SEC("license") = "GPL";
The attach target of entry_freplace is subprog_tc, and the tail callee in entry_freplace is entry_tc.
Then, the infinite loop will be entry_tc -> subprog_tc -> entry_freplace --tailcall-> entry_tc, because tail_call_cnt in entry_freplace will count from zero for every time of entry_freplace execution. Kernel will panic, like:
[ 15.310490] BUG: TASK stack guard page was hit at (____ptrval____) (stack is (____ptrval____)..(____ptrval____)) [ 15.310490] Oops: stack guard page: 0000 [#1] PREEMPT SMP NOPTI [ 15.310490] CPU: 1 PID: 89 Comm: test_progs Tainted: G OE 6.10.0-rc6-g026dcdae8d3e-dirty #72 [ 15.310490] Hardware name: QEMU Ubuntu 24.04 PC (i440FX + PIIX, 1996), BIOS 1.16.3-debian-1.16.3-2 04/01/2014 [ 15.310490] RIP: 0010:bpf_prog_3a140cef239a4b4f_subprog_tail+0x14/0x53 [ 15.310490] Code: cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc f3 0f 1e fa 0f 1f 44 00 00 0f 1f 00 55 48 89 e5 f3 0f 1e fa <50> 50 53 41 55 48 89 fb 49 bd 00 2a 46 82 98 9c ff ff 48 89 df 4c [ 15.310490] RSP: 0018:ffffb500c0aa0000 EFLAGS: 00000202 [ 15.310490] RAX: ffffb500c0aa0028 RBX: ffff9c98808b7e00 RCX: 0000000000008cb5 [ 15.310490] RDX: 0000000000000000 RSI: ffff9c9882462a00 RDI: ffff9c98808b7e00 [ 15.310490] RBP: ffffb500c0aa0000 R08: 0000000000000000 R09: 0000000000000000 [ 15.310490] R10: 0000000000000001 R11: 0000000000000000 R12: ffffb500c01af000 [ 15.310490] R13: ffffb500c01cd000 R14: 0000000000000000 R15: 0000000000000000 [ 15.310490] FS: 00007f133b665140(0000) GS:ffff9c98bbd00000(0000) knlGS:0000000000000000 [ 15.310490] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 15.310490] CR2: ffffb500c0a9fff8 CR3: 0000000102478000 CR4: 00000000000006f0 [ 15.310490] Call Trace: [ 15.310490] <#DF> [ 15.310490] ? die+0x36/0x90 [ 15.310490] ? handle_stack_overflow+0x4d/0x60 [ 15.310490] ? exc_double_fault+0x117/0x1a0 [ 15.310490] ? asm_exc_double_fault+0x23/0x30 [ 15.310490] ? bpf_prog_3a140cef239a4b4f_subprog_tail+0x14/0x53 [ 15.310490] </#DF> [ 15.310490] <TASK> [ 15.310490] bpf_prog_85781a698094722f_entry+0x4c/0x64 [ 15.310490] bpf_prog_1c515f389a9059b4_entry2+0x19/0x1b [ 15.310490] ... [ 15.310490] bpf_prog_85781a698094722f_entry+0x4c/0x64 [ 15.310490] bpf_prog_1c515f389a9059b4_entry2+0x19/0x1b [ 15.310490] bpf_test_run+0x210/0x370 [ 15.310490] ? bpf_test_run+0x128/0x370 [ 15.310490] bpf_prog_test_run_skb+0x388/0x7a0 [ 15.310490] __sys_bpf+0xdbf/0x2c40 [ 15.310490] ? clockevents_program_event+0x52/0xf0 [ 15.310490] ? lock_release+0xbf/0x290 [ 15.310490] __x64_sys_bpf+0x1e/0x30 [ 15.310490] do_syscall_64+0x68/0x140 [ 15.310490] entry_SYSCALL_64_after_hwframe+0x76/0x7e [ 15.310490] RIP: 0033:0x7f133b52725d [ 15.310490] Code: ff c3 66 2e 0f 1f 84 00 00 00 00 00 90 f3 0f 1e fa 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 8b 0d 8b bb 0d 00 f7 d8 64 89 01 48 [ 15.310490] RSP: 002b:00007ffddbc10258 EFLAGS: 00000206 ORIG_RAX: 0000000000000141 [ 15.310490] RAX: ffffffffffffffda RBX: 00007ffddbc10828 RCX: 00007f133b52725d [ 15.310490] RDX: 0000000000000050 RSI: 00007ffddbc102a0 RDI: 000000000000000a [ 15.310490] RBP: 00007ffddbc10270 R08: 0000000000000000 R09: 00007ffddbc102a0 [ 15.310490] R10: 0000000000000064 R11: 0000000000000206 R12: 0000000000000004 [ 15.310490] R13: 0000000000000000 R14: 0000558ec4c24890 R15: 00007f133b6ed000 [ 15.310490] </TASK> [ 15.310490] Modules linked in: bpf_testmod(OE) [ 15.310490] ---[ end trace 0000000000000000 ]--- [ 15.310490] RIP: 0010:bpf_prog_3a140cef239a4b4f_subprog_tail+0x14/0x53 [ 15.310490] Code: cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc f3 0f 1e fa 0f 1f 44 00 00 0f 1f 00 55 48 89 e5 f3 0f 1e fa <50> 50 53 41 55 48 89 fb 49 bd 00 2a 46 82 98 9c ff ff 48 89 df 4c [ 15.310490] RSP: 0018:ffffb500c0aa0000 EFLAGS: 00000202 [ 15.310490] RAX: ffffb500c0aa0028 RBX: ffff9c98808b7e00 RCX: 0000000000008cb5 [ 15.310490] RDX: 0000000000000000 RSI: ffff9c9882462a00 RDI: ffff9c98808b7e00 [ 15.310490] RBP: ffffb500c0aa0000 R08: 0000000000000000 R09: 0000000000000000 [ 15.310490] R10: 0000000000000001 R11: 0000000000000000 R12: ffffb500c01af000 [ 15.310490] R13: ffffb500c01cd000 R14: 0000000000000000 R15: 0000000000000000 [ 15.310490] FS: 00007f133b665140(0000) GS:ffff9c98bbd00000(0000) knlGS:0000000000000000 [ 15.310490] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 15.310490] CR2: ffffb500c0a9fff8 CR3: 0000000102478000 CR4: 00000000000006f0 [ 15.310490] Kernel panic - not syncing: Fatal exception in interrupt [ 15.310490] Kernel Offset: 0x30000000 from 0xffffffff81000000
(relocation range: 0xffffffff80000000-0xffffffffbfffffff)
This patch prevents this panic by preventing updating extended prog to prog_array map and preventing extending a prog, which has been updated to prog_array map, with freplace prog.
If a prog or its subprog has been extended by freplace prog, the prog can not be updated to prog_array map.
If a prog has been updated to prog_array map, it or its subprog can not be extended by freplace prog.
BTW, fix a minor code style issue by replacing 8 spaces with a tab.
--- include/linux/bpf.h | 21 ++++++++++++++++++++ kernel/bpf/arraymap.c | 23 +++++++++++++++++++++- kernel/bpf/core.c | 1 + kernel/bpf/syscall.c | 21 ++++++++++++++------ kernel/bpf/trampoline.c | 43 +++++++++++++++++++++++++++++++++++++++++ 5 files changed, 102 insertions(+), 7 deletions(-)
include/linux/bpf.h +21 -0
@@ -1294,6 +1294,12 @@ bool __bpf_dynptr_is_rdonly(const struct bpf_dynptr_kern *ptr);#ifdef CONFIG_BPF_JIT int bpf_trampoline_link_prog (struct bpf_tramp_link *link,struct bpf_trampoline *tr);int bpf_trampoline_unlink_prog (struct bpf_tramp_link *link,struct bpf_trampoline *tr); +int bpf_extension_link_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog); +int bpf_extension_unlink_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog);struct bpf_trampoline *bpf_trampoline_get (u64 key,struct bpf_attach_target_info *tgt_info);void bpf_trampoline_put (struct bpf_trampoline *tr);
@@ -1383,6 +1389,18 @@ static inline int bpf_trampoline_unlink_prog(struct bpf_tramp_link *link, {return -ENOTSUPP ; } +static inline int bpf_extension_link_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog) +{ +return -ENOTSUPP ; +} +static inline int bpf_extension_unlink_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog) +{ +return -ENOTSUPP ; +}static inline struct bpf_trampoline *bpf_trampoline_get (u64 key,struct bpf_attach_target_info *tgt_info) {
@@ -1483,6 +1501,9 @@ struct bpf_prog_aux {bool xdp_has_frags;bool exception_cb;bool exception_boundary; +bool is_extended;/* true if extended by freplace program */ +u64 prog_array_member_cnt;/* counts how many times as member of prog_array */ +struct mutex ext_mutex;/* mutex for is_extended and prog_array_member_cnt */ struct bpf_arena *arena;/* BTF_KIND_FUNC_PROTO for valid attach_btf_id */ const struct btf_type *attach_func_proto;
kernel/bpf/arraymap.c +22 -1
@@ -947,6 +947,7 @@ static void *prog_fd_array_get_ptr(struct bpf_map *map, struct file *map_file, int fd) {struct bpf_prog *prog =bpf_prog_get (fd); +bool is_extended;if (IS_ERR (prog))return prog;
@@ -956,13 +957,33 @@ static void *prog_fd_array_get_ptr(struct bpf_map *map,return ERR_PTR (-EINVAL ); } +mutex_lock (&prog->aux->ext_mutex); + is_extended = prog->aux->is_extended; +if (!is_extended) + prog->aux->prog_array_member_cnt++; +mutex_unlock (&prog->aux->ext_mutex); +if (is_extended) { +/* Extended prog can not be tail callee. It's to prevent a +* potential infinite loop like: +* tail callee prog entry -> tail callee prog subprog -> +* freplace prog entry --tailcall-> tail callee prog entry. +*/ +bpf_prog_put (prog); +return ERR_PTR (-EBUSY ); + } +return prog; }static void prog_fd_array_put_ptr (struct bpf_map *map,void *ptr,bool need_defer) { +struct bpf_prog *prog = ptr; + +mutex_lock (&prog->aux->ext_mutex); + prog->aux->prog_array_member_cnt--; +mutex_unlock (&prog->aux->ext_mutex);/* bpf_prog is freed after one RCU or tasks trace grace period */ -bpf_prog_put (ptr); +bpf_prog_put (prog); }static u32 prog_fd_array_sys_lookup_elem (void *ptr)
kernel/bpf/core.c +1 -0
@@ -131,6 +131,7 @@ struct bpf_prog *bpf_prog_alloc_no_stats(unsigned int size, gfp_t gfp_extra_flagINIT_LIST_HEAD_RCU (&fp->aux->ksym_prefix.lnode);#endif mutex_init (&fp->aux->used_maps_mutex); +mutex_init (&fp->aux->ext_mutex);mutex_init (&fp->aux->dst_mutex);return fp;
kernel/bpf/syscall.c +15 -6
@@ -3212,15 +3212,21 @@ static void bpf_tracing_link_release(struct bpf_link *link) {struct bpf_tracing_link *tr_link = container_of(link, struct bpf_tracing_link, link.link); +struct bpf_prog *tgt_prog = tr_link->tgt_prog; -WARN_ON_ONCE (bpf_trampoline_unlink_prog (&tr_link->link, - tr_link->trampoline)); +if (link->prog->type ==BPF_PROG_TYPE_EXT ) +WARN_ON_ONCE (bpf_extension_unlink_prog (&tr_link->link, + tr_link->trampoline, + tgt_prog)); +else +WARN_ON_ONCE (bpf_trampoline_unlink_prog (&tr_link->link, + tr_link->trampoline));bpf_trampoline_put (tr_link->trampoline);/* tgt_prog is NULL if target is a kernel function */ -if (tr_link->tgt_prog) -bpf_prog_put (tr_link->tgt_prog); +if (tgt_prog) +bpf_prog_put (tgt_prog); }static void bpf_tracing_link_dealloc (struct bpf_link *link)
@@ -3354,7 +3360,7 @@ static int bpf_tracing_prog_attach(struct bpf_prog *prog,* in prog->aux * * - if prog->aux->dst_trampoline is NULL, the program has already been -* attached to a target and its initial target was cleared (below) +* attached to a target and its initial target was cleared (below) * * - if tgt_prog != NULL, the caller specified tgt_prog_fd + * target_btf_id using the link_create API.
@@ -3429,7 +3435,10 @@ static int bpf_tracing_prog_attach(struct bpf_prog *prog,if (err) goto out_unlock; - err =bpf_trampoline_link_prog (&link->link, tr); +if (prog->type ==BPF_PROG_TYPE_EXT ) + err =bpf_extension_link_prog (&link->link, tr, tgt_prog); +else + err =bpf_trampoline_link_prog (&link->link, tr);if (err) {bpf_link_cleanup (&link_primer); link =NULL ;
kernel/bpf/trampoline.c +43 -0
55 lines not on this page · raw message
Signature · 1 line
2.44.0
PATCH v6 2/3 selftests/bpf: Add a test case to confirm a tailcall infinite loop issue has been prevented
In reply to Leon Hwangcd tools/testing/selftests/bpf; ./test_progs -t tailcalls 335/26 tailcalls/tailcall_bpf2bpf_freplace:OK
335 tailcalls:OK
Summary: 1/26 PASSED, 0 SKIPPED, 0 FAILED
--- .../selftests/bpf/prog_tests/tailcalls.c | 99 ++++++++++++++++++- .../testing/selftests/bpf/progs/tc_bpf2bpf.c | 24 ++++- 2 files changed, 119 insertions(+), 4 deletions(-)
tools/testing/selftests/bpf/prog_tests/tailcalls.c +97 -2
@@ -1525,7 +1525,8 @@ static void test_tailcall_freplace(void) prog_fd =bpf_program__fd (tc_skel->progs.entry_tc); freplace_prog = freplace_skel->progs.entry_freplace; - err =bpf_program__set_attach_target (freplace_prog, prog_fd,"subprog" ); + err =bpf_program__set_attach_target (freplace_prog, prog_fd, +"subprog_tailcall_tc" );if (!ASSERT_OK (err,"set_attach_target" )) goto out;
@@ -1534,7 +1535,7 @@ static void test_tailcall_freplace(void) goto out; freplace_link =bpf_program__attach_freplace (freplace_prog, prog_fd, -"subprog" ); +"subprog_tailcall_tc" );if (!ASSERT_OK_PTR (freplace_link,"attach_freplace" )) goto out;
@@ -1556,6 +1557,98 @@ static void test_tailcall_freplace(void)tailcall_freplace__destroy (freplace_skel); } +/* test_tailcall_bpf2bpf_freplace checks the failure that fails to attach a tail +* callee prog with freplace prog or fails to update an extended prog to +* prog_array map. +*/ +static void test_tailcall_bpf2bpf_freplace (void ) +{ +struct tailcall_freplace *freplace_skel =NULL ; +struct bpf_link *freplace_link =NULL ; +struct tc_bpf2bpf *tc_skel =NULL ; +char buff[128 ] = {}; +int prog_fd, map_fd; +int err, key; + +LIBBPF_OPTS (bpf_test_run_opts, topts, + .data_in = buff, + .data_size_in = sizeof(buff), + .repeat = 1, + ); + + tc_skel =tc_bpf2bpf__open_and_load (); +if (!ASSERT_OK_PTR (tc_skel,"tc_bpf2bpf__open_and_load" )) + goto out; + + prog_fd =bpf_program__fd (tc_skel->progs.entry_tc); + freplace_skel =tailcall_freplace__open (); +if (!ASSERT_OK_PTR (freplace_skel,"tailcall_freplace__open" )) + goto out; + + err =bpf_program__set_attach_target (freplace_skel->progs.entry_freplace, + prog_fd,"subprog_tc" ); +if (!ASSERT_OK (err,"set_attach_target" )) + goto out; + + err =tailcall_freplace__load (freplace_skel); +if (!ASSERT_OK (err,"tailcall_freplace__load" )) + goto out; + +/* OK to attach then detach freplace prog. */ + + freplace_link =bpf_program__attach_freplace (freplace_skel->progs.entry_freplace, + prog_fd,"subprog_tc" ); +if (!ASSERT_OK_PTR (freplace_link,"attach_freplace" )) + goto out; + + err =bpf_link__destroy (freplace_link); +if (!ASSERT_OK (err,"destroy link" )) + goto out; + +/* OK to update prog_array map then delete element from the map. */ + + key =0 ; + map_fd =bpf_map__fd (freplace_skel->maps.jmp_table); + err =bpf_map_update_elem (map_fd, &key, &prog_fd,BPF_ANY ); +if (!ASSERT_OK (err,"update jmp_table" )) + goto out; + + err =bpf_map_delete_elem (map_fd, &key); +if (!ASSERT_OK (err,"delete_elem from jmp_table" )) + goto out; + +/* Fail to attach a tail callee prog with freplace prog. */ + + err =bpf_map_update_elem (map_fd, &key, &prog_fd,BPF_ANY ); +if (!ASSERT_OK (err,"update jmp_table" )) + goto out; + + freplace_link =bpf_program__attach_freplace (freplace_skel->progs.entry_freplace, + prog_fd,"subprog_tc" ); +if (!ASSERT_ERR_PTR (freplace_link,"attach_freplace failure" )) + goto out; + + err =bpf_map_delete_elem (map_fd, &key); +if (!ASSERT_OK (err,"delete_elem from jmp_table" )) + goto out; + +/* Fail to update an extended prog to prog_array map. */ + + freplace_link =bpf_program__attach_freplace (freplace_skel->progs.entry_freplace, + prog_fd,"subprog_tc" ); +if (!ASSERT_OK_PTR (freplace_link,"attach_freplace" )) + goto out; + + err =bpf_map_update_elem (map_fd, &key, &prog_fd,BPF_ANY ); +if (!ASSERT_ERR (err,"update jmp_table failure" )) + goto out; + +out: +bpf_link__destroy (freplace_link); +tailcall_freplace__destroy (freplace_skel); +tc_bpf2bpf__destroy (tc_skel); +} +void test_tailcalls (void ) {if (test__start_subtest ("tailcall_1" ))
@@ -1606,4 +1699,6 @@ void test_tailcalls(void)test_tailcall_bpf2bpf_hierarchy_3 ();if (test__start_subtest ("tailcall_freplace" ))test_tailcall_freplace (); +if (test__start_subtest ("tailcall_bpf2bpf_freplace" )) +test_tailcall_bpf2bpf_freplace (); }
tools/testing/selftests/bpf/progs/tc_bpf2bpf.c +22 -2
@@ -4,11 +4,30 @@#include <bpf/bpf_helpers.h> #include "bpf_misc.h" +struct { + __uint(type, BPF_MAP_TYPE_PROG_ARRAY); + __uint(max_entries, 1); + __uint(key_size, sizeof(__u32)); + __uint(value_size, sizeof(__u32)); +} jmp_table SEC(".maps"); + +__noinline +int subprog_tailcall_tc(struct __sk_buff *skb) +{ +int ret =1 ; + +bpf_tail_call_static (skb, &jmp_table,0 ); +__sink (skb); +__sink (ret); +return ret; +} +__noinline -int subprog(struct __sk_buff *skb) +int subprog_tc(struct __sk_buff *skb) {int ret =1 ; +__sink (skb);__sink (ret);return ret; }
@@ -16,7 +35,8 @@ int subprog(struct __sk_buff *skb) SEC("tc")int entry_tc (struct __sk_buff *skb) { -return subprog (skb); +subprog_tc (skb); +return subprog_tailcall_tc (skb); } char __license[] SEC("license") = "GPL";
Signature · 1 line
2.44.0
PATCH v6 3/3 selftests/bpf: Add cases to test tailcall in freplace
In reply to Leon Hwangcd tools/testing/selftests/bpf; ./test_progs -t tailcalls
335/27 tailcalls/tailcall_bpf2bpf_hierarchy_freplace_1:OK 335/28 tailcalls/tailcall_bpf2bpf_hierarchy_freplace_2:OK 335 tailcalls:OK
Summary: 1/28 PASSED, 0 SKIPPED, 0 FAILED
--- .../selftests/bpf/prog_tests/tailcalls.c | 97 +++++++++++++++++++ .../tailcall_bpf2bpf_hierarchy_freplace.c | 30 ++++++ .../testing/selftests/bpf/progs/tc_bpf2bpf.c | 13 +++ 3 files changed, 140 insertions(+) create mode 100644 tools/testing/selftests/bpf/progs/tailcall_bpf2bpf_hierarchy_freplace.c
tools/testing/selftests/bpf/prog_tests/tailcalls.c +97 -0
@@ -5,6 +5,7 @@#include "tailcall_poke.skel.h" #include "tailcall_bpf2bpf_hierarchy2.skel.h" #include "tailcall_bpf2bpf_hierarchy3.skel.h" +#include "tailcall_bpf2bpf_hierarchy_freplace.skel.h" #include "tailcall_freplace.skel.h" #include "tc_bpf2bpf.skel.h"
@@ -1649,6 +1650,98 @@ static void test_tailcall_bpf2bpf_freplace(void)tc_bpf2bpf__destroy (tc_skel); } +static void test_tailcall_bpf2bpf_hierarchy_freplace (bool freplace_subprog, +bool target_entry2, +int count1,int count2) +{ +struct tailcall_bpf2bpf_hierarchy_freplace *freplace_skel =NULL ; +struct bpf_link *freplace_link =NULL ; +struct tc_bpf2bpf *tc_skel =NULL ; +int prog_fd, map_fd; +char buff[128 ] = {}; +int err, key, val; + +LIBBPF_OPTS (bpf_test_run_opts, topts, + .data_in = buff, + .data_size_in = sizeof(buff), + .repeat = 1, + ); + + tc_skel =tc_bpf2bpf__open_and_load (); +if (!ASSERT_OK_PTR (tc_skel,"tc_bpf2bpf__open_and_load" )) + goto out; + + prog_fd =bpf_program__fd (target_entry2 ? tc_skel->progs.entry_tc_2 : + tc_skel->progs.entry_tc); + freplace_skel =tailcall_bpf2bpf_hierarchy_freplace__open (); +if (!ASSERT_OK_PTR (freplace_skel,"tailcall_bpf2bpf_hierarchy_freplace__open" )) + goto out; + + err =bpf_program__set_attach_target (freplace_skel->progs.entry_freplace, + prog_fd, freplace_subprog ? +"subprog_tailcall_tc" :"entry_tc" ); +if (!ASSERT_OK (err,"set_attach_target" )) + goto out; + + err =tailcall_bpf2bpf_hierarchy_freplace__load (freplace_skel); +if (!ASSERT_OK (err,"tailcall_bpf2bpf_hierarchy_freplace__load" )) + goto out; + + val =bpf_program__fd (freplace_skel->progs.entry_freplace); + map_fd =bpf_map__fd (freplace_skel->maps.jmp_table); + key =0 ; + err =bpf_map_update_elem (map_fd, &key, &val,BPF_ANY ); +if (!ASSERT_OK (err,"update jmp_table" )) + goto out; + + freplace_link =bpf_program__attach_freplace (freplace_skel->progs.entry_freplace, + prog_fd, freplace_subprog ? +"subprog_tailcall_tc" :"entry_tc" ); +if (!ASSERT_OK_PTR (freplace_link,"attach_freplace" )) + goto out; + + err =bpf_prog_test_run_opts (prog_fd, &topts); +ASSERT_OK (err,"test_run_opts" ); +ASSERT_EQ (topts.retval, count1,"test_run_opts retval" ); + + err =bpf_map_delete_elem (map_fd, &key); +if (!ASSERT_OK (err,"delete_elem from jmp_table" )) + goto out; + + err =bpf_prog_test_run_opts (prog_fd, &topts); +ASSERT_OK (err,"test_run_opts again" ); +ASSERT_EQ (topts.retval, count2,"test_run_opts retval again" ); + +out: +bpf_link__destroy (freplace_link); +tailcall_bpf2bpf_hierarchy_freplace__destroy (freplace_skel); +tc_bpf2bpf__destroy (tc_skel); +} + +/* test_tailcall_bpf2bpf_hierarchy_freplace_1 checks the count value of tail +* call limit enforcement matches with expectation for the case: +* +* subprog_tail --tailcall-> entry_freplace +* entry_tc --jump-> entry_freplace < +* subprog_tail --tailcall-> entry_freplace +*/ +static void test_tailcall_bpf2bpf_hierarchy_freplace_1 (void ) +{ +test_tailcall_bpf2bpf_hierarchy_freplace (false, false,34 ,35 ); +} + +/* test_tailcall_bpf2bpf_hierarchy_freplace_2 checks the count value of tail +* call limit enforcement matches with expectation for the case: +* +* subprog_tail --tailcall-> entry_freplace +* entry_tc_2 --> subprog_tailcall_tc (call 10 times) --jump-> entry_freplace < +* subprog_tail --tailcall-> entry_freplace +*/ +static void test_tailcall_bpf2bpf_hierarchy_freplace_2 (void ) +{ +test_tailcall_bpf2bpf_hierarchy_freplace (true, true,340 ,350 ); +} +void test_tailcalls (void ) {if (test__start_subtest ("tailcall_1" ))
@@ -1701,4 +1794,8 @@ void test_tailcalls(void)test_tailcall_freplace ();if (test__start_subtest ("tailcall_bpf2bpf_freplace" ))test_tailcall_bpf2bpf_freplace (); +if (test__start_subtest ("tailcall_bpf2bpf_hierarchy_freplace_1" )) +test_tailcall_bpf2bpf_hierarchy_freplace_1 (); +if (test__start_subtest ("tailcall_bpf2bpf_hierarchy_freplace_2" )) +test_tailcall_bpf2bpf_hierarchy_freplace_2 (); }
tools/testing/selftests/bpf/progs/tailcall_bpf2bpf_hierarchy_freplace.c new file +30 -0
@@ -0,0 +1,30 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <linux/bpf.h> +#include <bpf/bpf_helpers.h> + +struct { + __uint(type, BPF_MAP_TYPE_PROG_ARRAY); + __uint(max_entries, 1); + __uint(key_size, sizeof(__u32)); + __uint(value_size, sizeof(__u32)); +} jmp_table SEC(".maps"); + +int count =0 ; + +static __noinline +int subprog_tail(struct __sk_buff *skb) +{ +bpf_tail_call_static (skb, &jmp_table,0 ); +return 0 ; +} + +SEC("freplace") +int entry_freplace (struct __sk_buff *skb) +{ + count++; +subprog_tail (skb); +subprog_tail (skb); +return count; +} + +char __license[] SEC("license") = "GPL";
tools/testing/selftests/bpf/progs/tc_bpf2bpf.c +13 -0
@@ -39,4 +39,17 @@ int entry_tc(struct __sk_buff *skb)return subprog_tailcall_tc (skb); } +SEC("tc") +int entry_tc_2 (struct __sk_buff *skb) +{ +int ret, i; + +for (i =0 ; i <10 ; i++) { + ret =subprog_tailcall_tc (skb); +__sink (ret); + } + +return ret; +} + char __license[] SEC("license") = "GPL";
Signature · 1 line
2.44.0
Re: [PATCH bpf-next v6 1/3] bpf: Prevent tailcall infinite loop caused by freplace
In reply to Leon HwangQuoted 2 lines · Leon Hwang
This patch prevents an infinite loop issue caused by combination of tailcall and freplace.
[...]
Quoted 4 lines
Reported-by kernel test robot <[email protected]>Signed-off-by Leon Hwang <[email protected]>---
This seems correct as far as I can tell.
[...]
Re: [PATCH bpf-next v6 2/3] selftests/bpf: Add a test case to confirm a tailcall infinite loop issue has been prevented
In reply to Leon HwangQuoted 4 lines · Leon Hwang
cd
tools/testing/selftests/bpf; ./test_progs -t tailcalls 335/26 tailcalls/tailcall_bpf2bpf_freplace:OK
335 tailcalls:OK
Summary: 1/26 PASSED, 0 SKIPPED, 0 FAILED
Nit: commit message would be more useful with a small description of
the added test.
Quoted 3 lines
Signed-off-by Leon Hwang <[email protected]>---
[...]
Eduard Zingerman
maintainerRe: [PATCH bpf-next v6 1/3] bpf: Prevent tailcall infinite loop caused by freplace
In reply to Leon HwangOn Wed, 2024-10-09 at 00:13 +0800, Leon Hwang wrote:
[...]
Quoted 2 lines
These tags are misplaced: "Closes" link is for v5 version of this series. "Closes" should refer to error reports for something that is already a part of the kernel.
[...]
Eduard Zingerman
maintainerRe: [PATCH bpf-next v6 3/3] selftests/bpf: Add cases to test tailcall in freplace
In reply to Leon HwangQuoted 8 lines · Leon Hwang
cd
tools/testing/selftests/bpf; ./test_progs -t tailcalls335/27 tailcalls/tailcall_bpf2bpf_hierarchy_freplace_1:OK 335/28 tailcalls/tailcall_bpf2bpf_hierarchy_freplace_2:OK 335 tailcalls:OKSummary: 1/28 PASSED, 0 SKIPPED, 0 FAILED
Signed-off-by Leon Hwang <[email protected]>---
Tbh, I don't think these tests are necessary.
Patch #2 already covers changes in patch #1.
[...]
Re: [PATCH bpf-next v6 1/3] bpf: Prevent tailcall infinite loop caused by freplace
In reply to Eduard ZingermanQuoted 11 lines · Eduard Zingerman
On Wed, 2024-10-09 at 00:13 +0800, Leon Hwang wrote:
[...]
Quoted 2 lines
These tags are misplaced: "Closes" link is for v5 version of this series. "Closes" should refer to error reports for something that is already a part of the kernel.
My bad. Thank you for your clarification.
Thanks,
Leon
Re: [PATCH bpf-next v6 2/3] selftests/bpf: Add a test case to confirm a tailcall infinite loop issue has been prevented
In reply to Eduard ZingermanQuoted 9 lines · Eduard Zingerman
Quoted 4 lines · Leon Hwang
cd
tools/testing/selftests/bpf; ./test_progs -t tailcalls 335/26 tailcalls/tailcall_bpf2bpf_freplace:OK
335 tailcalls:OK
Summary: 1/26 PASSED, 0 SKIPPED, 0 FAILEDNit: commit message would be more useful with a small description of
the added test.
Sure. The commit message can be:
Add a test case to confirm that it must fail to attach a tail callee prog with freplace prog, and must fail to update an extended prog to prog_array map. It's to prevent an infinite loop issue cause by the combination of tailcall and freplace.
Quoted 8 lines
Quoted 3 lines
Signed-off-by Leon Hwang <[email protected]>---
Acked-by Eduard Zingerman <[email protected]>[...]
Thanks,
Leon
Re: [PATCH bpf-next v6 3/3] selftests/bpf: Add cases to test tailcall in freplace
In reply to Eduard ZingermanQuoted 7 lines · Eduard Zingerman
Quoted 6 lines · Leon Hwang
cd
tools/testing/selftests/bpf; ./test_progs -t tailcalls335/27 tailcalls/tailcall_bpf2bpf_hierarchy_freplace_1:OK 335/28 tailcalls/tailcall_bpf2bpf_hierarchy_freplace_2:OK 335 tailcalls:OKSummary: 1/28 PASSED, 0 SKIPPED, 0 FAILED
Quoted 8 lines
Quoted 2 lines
Signed-off-by Leon Hwang <[email protected]>---
Tbh, I don't think these tests are necessary.
Patch #2 already covers changes in patch #1.[...]
You are right.
I should provide the commit message to tell the reason why to add these two test cases:
In order to confirm tailcall in freplace is OK and won't be broken by patch of preventing tailcall infinite loop caused by freplace or other patches in the future, add two test cases to confirm that freplace is OK to tail call itself or other freplace prog, even if the target prog of freplace is a subprog and the subprog is called many times in its caller.
Thanks,
Leon
Re: [PATCH bpf-next v6 1/3] bpf: Prevent tailcall infinite loop caused by freplace
In reply to Leon HwangQuoted 45 lines · Leon Hwang
This patch prevents an infinite loop issue caused by combination of tailcall and freplace.
For example:
tc_bpf2bpf.c:// SPDX-License-Identifier: GPL-2.0
\#include <
linux/bpf.h>
\#include <bpf/bpf_helpers.h>
__noinline
intsubprog_tc(struct __sk_buff *skb){ return skb->len * 2; }
SEC("tc")
intentry_tc(struct __sk_buff *skb){ return subprog_tc(skb); }char __license[]
SEC("license")= "GPL";
tailcall_freplace.c:// SPDX-License-Identifier: GPL-2.0
\#include <
linux/bpf.h>
\#include <bpf/bpf_helpers.h>struct { __uint(type, BPF_MAP_TYPE_PROG_ARRAY); __uint(max_entries, 1); __uint(key_size, sizeof(__u32)); __uint(value_size, sizeof(__u32)); } jmp_table SEC(".maps");int count = 0;
SEC("freplace")
intentry_freplace(struct __sk_buff *skb)
Quoted 7 lines
{ count++; bpf_tail_call_static(skb, &jmp_table, 0); return count; }char __license[]
SEC("license")= "GPL";
No need to put the whole selftest into commit log.
The below few paragraphs are enough:
Quoted 7 lines
The attach target of
entry_freplaceissubprog_tc, and the tail callee inentry_freplaceisentry_tc.Then, the infinite loop will be
entry_tc->subprog_tc->entry_freplace--tailcall->entry_tc, becausetail_call_cntinentry_freplacewill count from zero for every time ofentry_freplaceexecution. Kernel will panic, like:
99% of this full dump below is nothing but noise.
Drop it. Above "kernel will panic" is enough.
Quoted 91 lines
[ 15.310490] BUG: TASK stack guard page was hit at (____ptrval____) (stack is (____ptrval____)..(____ptrval____)) [ 15.310490] Oops: stack guard page: 0000 [#1] PREEMPT SMP NOPTI [ 15.310490] CPU: 1 PID: 89 Comm: test_progs Tainted: G OE 6.10.0-rc6-g026dcdae8d3e-dirty #72 [ 15.310490] Hardware name: QEMU Ubuntu 24.04 PC (i440FX + PIIX, 1996), BIOS 1.16.3-debian-1.16.3-2 04/01/2014 [ 15.310490] RIP: 0010:bpf_prog_3a140cef239a4b4f_subprog_tail+0x14/0x53 [ 15.310490] Code: cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc f3 0f 1e fa 0f 1f 44 00 00 0f 1f 00 55 48 89 e5 f3 0f 1e fa <50> 50 53 41 55 48 89 fb 49 bd 00 2a 46 82 98 9c ff ff 48 89 df 4c [ 15.310490] RSP: 0018:ffffb500c0aa0000 EFLAGS: 00000202 [ 15.310490] RAX: ffffb500c0aa0028 RBX: ffff9c98808b7e00 RCX: 0000000000008cb5 [ 15.310490] RDX: 0000000000000000 RSI: ffff9c9882462a00 RDI: ffff9c98808b7e00 [ 15.310490] RBP: ffffb500c0aa0000 R08: 0000000000000000 R09: 0000000000000000 [ 15.310490] R10: 0000000000000001 R11: 0000000000000000 R12: ffffb500c01af000 [ 15.310490] R13: ffffb500c01cd000 R14: 0000000000000000 R15: 0000000000000000 [ 15.310490] FS: 00007f133b665140(0000) GS:ffff9c98bbd00000(0000) knlGS:0000000000000000 [ 15.310490] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 15.310490] CR2: ffffb500c0a9fff8 CR3: 0000000102478000 CR4: 00000000000006f0 [ 15.310490] Call Trace: [ 15.310490] <#DF> [ 15.310490] ? die+0x36/0x90 [ 15.310490] ? handle_stack_overflow+0x4d/0x60 [ 15.310490] ? exc_double_fault+0x117/0x1a0 [ 15.310490] ? asm_exc_double_fault+0x23/0x30 [ 15.310490] ? bpf_prog_3a140cef239a4b4f_subprog_tail+0x14/0x53 [ 15.310490] </#DF> [ 15.310490] <TASK> [ 15.310490] bpf_prog_85781a698094722f_entry+0x4c/0x64 [ 15.310490] bpf_prog_1c515f389a9059b4_entry2+0x19/0x1b [ 15.310490] ... [ 15.310490] bpf_prog_85781a698094722f_entry+0x4c/0x64 [ 15.310490] bpf_prog_1c515f389a9059b4_entry2+0x19/0x1b [ 15.310490] bpf_test_run+0x210/0x370 [ 15.310490] ? bpf_test_run+0x128/0x370 [ 15.310490] bpf_prog_test_run_skb+0x388/0x7a0 [ 15.310490] __sys_bpf+0xdbf/0x2c40 [ 15.310490] ? clockevents_program_event+0x52/0xf0 [ 15.310490] ? lock_release+0xbf/0x290 [ 15.310490] __x64_sys_bpf+0x1e/0x30 [ 15.310490] do_syscall_64+0x68/0x140 [ 15.310490] entry_SYSCALL_64_after_hwframe+0x76/0x7e [ 15.310490] RIP: 0033:0x7f133b52725d [ 15.310490] Code: ff c3 66 2e 0f 1f 84 00 00 00 00 00 90 f3 0f 1e fa 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 8b 0d 8b bb 0d 00 f7 d8 64 89 01 48 [ 15.310490] RSP: 002b:00007ffddbc10258 EFLAGS: 00000206 ORIG_RAX: 0000000000000141 [ 15.310490] RAX: ffffffffffffffda RBX: 00007ffddbc10828 RCX: 00007f133b52725d [ 15.310490] RDX: 0000000000000050 RSI: 00007ffddbc102a0 RDI: 000000000000000a [ 15.310490] RBP: 00007ffddbc10270 R08: 0000000000000000 R09: 00007ffddbc102a0 [ 15.310490] R10: 0000000000000064 R11: 0000000000000206 R12: 0000000000000004 [ 15.310490] R13: 0000000000000000 R14: 0000558ec4c24890 R15: 00007f133b6ed000 [ 15.310490] </TASK> [ 15.310490] Modules linked in: bpf_testmod(OE) [ 15.310490] ---[ end trace 0000000000000000 ]--- [ 15.310490] RIP: 0010:bpf_prog_3a140cef239a4b4f_subprog_tail+0x14/0x53 [ 15.310490] Code: cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc f3 0f 1e fa 0f 1f 44 00 00 0f 1f 00 55 48 89 e5 f3 0f 1e fa <50> 50 53 41 55 48 89 fb 49 bd 00 2a 46 82 98 9c ff ff 48 89 df 4c [ 15.310490] RSP: 0018:ffffb500c0aa0000 EFLAGS: 00000202 [ 15.310490] RAX: ffffb500c0aa0028 RBX: ffff9c98808b7e00 RCX: 0000000000008cb5 [ 15.310490] RDX: 0000000000000000 RSI: ffff9c9882462a00 RDI: ffff9c98808b7e00 [ 15.310490] RBP: ffffb500c0aa0000 R08: 0000000000000000 R09: 0000000000000000 [ 15.310490] R10: 0000000000000001 R11: 0000000000000000 R12: ffffb500c01af000 [ 15.310490] R13: ffffb500c01cd000 R14: 0000000000000000 R15: 0000000000000000 [ 15.310490] FS: 00007f133b665140(0000) GS:ffff9c98bbd00000(0000) knlGS:0000000000000000 [ 15.310490] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 15.310490] CR2: ffffb500c0a9fff8 CR3: 0000000102478000 CR4: 00000000000006f0 [ 15.310490] Kernel panic - not syncing: Fatal exception in interrupt [ 15.310490] Kernel Offset: 0x30000000 from 0xffffffff81000000
Quoted 1 line
(relocation range: 0xffffffff80000000-0xffffffffbfffffff)
Below paragraphs are almost ok, but pls use imperative language. Instead of "this patch prevents ..."
say "Fix the issue by preventing update of ext prog .."
Consider using grammarly or chatgpt to make it less nerdy.
Quoted 137 lines
This patch prevents this panic by preventing updating extended prog to
prog_arraymap and preventing extending a prog, which has been updated toprog_arraymap, with freplace prog.If a prog or its subprog has been extended by freplace prog, the prog can not be updated to
prog_arraymap.If a prog has been updated to
prog_arraymap, it or its subprog can not be extended by freplace prog.BTW, fix a minor code style issue by replacing 8 spaces with a tab.
Reported-by kernel test robot <[email protected]>Signed-off-by Leon Hwang <[email protected]>--- include/linux/bpf.h | 21 ++++++++++++++++++++ kernel/bpf/arraymap.c | 23 +++++++++++++++++++++- kernel/bpf/core.c | 1 + kernel/bpf/syscall.c | 21 ++++++++++++++------ kernel/bpf/trampoline.c | 43 +++++++++++++++++++++++++++++++++++++++++ 5 files changed, 102 insertions(+), 7 deletions(-)include/linux/bpf.h +21
-0@@ -1294,6 +1294,12 @@ bool __bpf_dynptr_is_rdonly(const struct bpf_dynptr_kern *ptr);#ifdef CONFIG_BPF_JIT int bpf_trampoline_link_prog (struct bpf_tramp_link *link,struct bpf_trampoline *tr);int bpf_trampoline_unlink_prog (struct bpf_tramp_link *link,struct bpf_trampoline *tr); +int bpf_extension_link_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog); +int bpf_extension_unlink_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog);struct bpf_trampoline *bpf_trampoline_get (u64 key,struct bpf_attach_target_info *tgt_info);void bpf_trampoline_put (struct bpf_trampoline *tr);@@ -1383,6 +1389,18 @@ static inline int bpf_trampoline_unlink_prog(struct bpf_tramp_link *link, {return -ENOTSUPP ; } +static inline int bpf_extension_link_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog) +{ +return -ENOTSUPP ; +} +static inline int bpf_extension_unlink_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog) +{ +return -ENOTSUPP ; +}static inline struct bpf_trampoline *bpf_trampoline_get (u64 key,struct bpf_attach_target_info *tgt_info) {@@ -1483,6 +1501,9 @@ struct bpf_prog_aux {bool xdp_has_frags;bool exception_cb;bool exception_boundary; +bool is_extended;/* true if extended by freplace program */ +u64 prog_array_member_cnt;/* counts how many times as member of prog_array */ +struct mutex ext_mutex;/* mutex for is_extended and prog_array_member_cnt */ struct bpf_arena *arena;/* BTF_KIND_FUNC_PROTO for valid attach_btf_id */ const struct btf_type *attach_func_proto;kernel/bpf/arraymap.c +22
-1@@ -947,6 +947,7 @@ static void *prog_fd_array_get_ptr(struct bpf_map *map, struct file *map_file, int fd) {struct bpf_prog *prog =bpf_prog_get (fd); +bool is_extended;if (IS_ERR (prog))return prog;@@ -956,13 +957,33 @@ static void *prog_fd_array_get_ptr(struct bpf_map *map,return ERR_PTR (-EINVAL ); } +mutex_lock (&prog->aux->ext_mutex); + is_extended = prog->aux->is_extended; +if (!is_extended) + prog->aux->prog_array_member_cnt++; +mutex_unlock (&prog->aux->ext_mutex); +if (is_extended) { +/* Extended prog can not be tail callee. It's to prevent a +* potential infinite loop like: +* tail callee prog entry -> tail callee prog subprog -> +* freplace prog entry --tailcall-> tail callee prog entry. +*/ +bpf_prog_put (prog); +return ERR_PTR (-EBUSY ); + } +return prog; }static void prog_fd_array_put_ptr (struct bpf_map *map,void *ptr,bool need_defer) { +struct bpf_prog *prog = ptr; + +mutex_lock (&prog->aux->ext_mutex); + prog->aux->prog_array_member_cnt--; +mutex_unlock (&prog->aux->ext_mutex);/* bpf_prog is freed after one RCU or tasks trace grace period */ -bpf_prog_put (ptr); +bpf_prog_put (prog); }static u32 prog_fd_array_sys_lookup_elem (void *ptr)kernel/bpf/core.c +1
-0@@ -131,6 +131,7 @@ struct bpf_prog *bpf_prog_alloc_no_stats(unsigned int size, gfp_t gfp_extra_flagINIT_LIST_HEAD_RCU (&fp->aux->ksym_prefix.lnode);#endif mutex_init (&fp->aux->used_maps_mutex); +mutex_init (&fp->aux->ext_mutex);mutex_init (&fp->aux->dst_mutex);return fp;kernel/bpf/syscall.c +1
-0@@ -3212,15 +3212,21 @@ static void bpf_tracing_link_release(struct bpf_link *link) {struct bpf_tracing_link *tr_link = container_of(link, struct bpf_tracing_link, link.link); +struct bpf_prog *tgt_prog = tr_link->tgt_prog;
kernel/bpf/syscall.c static void bpf_tracing_link_release(struct bpf_link *link) · line 3223
Quoted 10 lines
kernel/bpf/syscall.c +7
-2-WARN_ON_ONCE (bpf_trampoline_unlink_prog (&tr_link->link, - tr_link->trampoline)); +if (link->prog->type ==BPF_PROG_TYPE_EXT ) +WARN_ON_ONCE (bpf_extension_unlink_prog (&tr_link->link, + tr_link->trampoline, + tgt_prog)); +else +WARN_ON_ONCE (bpf_trampoline_unlink_prog (&tr_link->link, + tr_link->trampoline));
This early demux into two helpers looks odd.
I think it would be cleaner to add this logic to bpf_trampoline_unlink_prog() Just extend it with an extra prog argument.
Quoted 20 lines
kernel/bpf/syscall.c +3
-3bpf_trampoline_put (tr_link->trampoline);/* tgt_prog is NULL if target is a kernel function */ -if (tr_link->tgt_prog) -bpf_prog_put (tr_link->tgt_prog); +if (tgt_prog) +bpf_prog_put (tgt_prog); }static void bpf_tracing_link_dealloc (struct bpf_link *link)@@ -3354,7 +3360,7 @@ static int bpf_tracing_prog_attach(struct bpf_prog *prog,* in prog->aux * * - if prog->aux->dst_trampoline is NULL, the program has already been -* attached to a target and its initial target was cleared (below) +* attached to a target and its initial target was cleared (below) * * - if tgt_prog != NULL, the caller specified tgt_prog_fd + * target_btf_id using the link_create API.
kernel/bpf/syscall.c static int bpf_tracing_prog_attach(struct bpf_prog *prog, · line 3441
Quoted 8 lines
kernel/bpf/syscall.c +4
-1@@ -3429,7 +3435,10 @@ static int bpf_tracing_prog_attach(struct bpf_prog *prog,if (err) goto out_unlock; - err =bpf_trampoline_link_prog (&link->link, tr); +if (prog->type ==BPF_PROG_TYPE_EXT ) + err =bpf_extension_link_prog (&link->link, tr, tgt_prog); +else + err =bpf_trampoline_link_prog (&link->link, tr);
same here.
Quoted 9 lines
kernel/bpf/syscall.c +0
-0if (err) {bpf_link_cleanup (&link_primer); link =NULL ;kernel/bpf/trampoline.c +0
-0@@ -580,6 +580,35 @@ int bpf_trampoline_link_prog(struct bpf_tramp_link *link, struct bpf_trampolinereturn err;
kernel/bpf/trampoline.c int bpf_trampoline_link_prog(struct bpf_tramp_link *link, struct bpf_trampoline · line 590
Quoted 10 lines
kernel/bpf/trampoline.c +8
-0} +int bpf_extension_link_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog) +{ +struct bpf_prog_aux *aux = tgt_prog->aux; +int err; + +mutex_lock (&aux->ext_mutex);
pls use guard(mutex) as I suggested earlier.
Quoted 29 lines
kernel/bpf/trampoline.c +22
-0+if (aux->prog_array_member_cnt) { +/* Program extensions can not extend target prog when the target +* prog has been updated to any prog_array map as tail callee. +* It's to prevent a potential infinite loop like: +* tgt prog entry -> tgt prog subprog -> freplace prog entry +* --tailcall-> tgt prog entry. +*/ + err = -EBUSY ; + goto out_unlock; + } + + err =bpf_trampoline_link_prog (link, tr); +if (err) + goto out_unlock; + + aux->is_extended = true; +out_unlock: +mutex_unlock (&aux->ext_mutex); +return err; +} +static int __bpf_trampoline_unlink_prog (struct bpf_tramp_link *link,struct bpf_trampoline *tr) {enum bpf_tramp_prog_type kind;@@ -609,6 +638,20 @@ int bpf_trampoline_unlink_prog(struct bpf_tramp_link *link, struct bpf_trampolinreturn err; } +int bpf_extension_unlink_prog(struct bpf_tramp_link *link,
kernel/bpf/trampoline.c int bpf_trampoline_unlink_prog(struct bpf_tramp_link *link, struct bpf_trampolin · line 651
Quoted 10 lines
kernel/bpf/trampoline.c +10
-0+struct bpf_trampoline *tr, + struct bpf_prog *tgt_prog) +{ + struct bpf_prog_aux *aux = tgt_prog->aux; +int err; + +mutex_lock (&aux->ext_mutex); + err =bpf_trampoline_unlink_prog (link, tr); + aux->is_extended = false; +mutex_unlock (&aux->ext_mutex);
same suggestions.
pw-bot: cr
Re: [PATCH bpf-next v6 3/3] selftests/bpf: Add cases to test tailcall in freplace
In reply to Leon HwangQuoted 22 lines · Leon Hwang
Quoted 7 lines · Eduard Zingerman
Quoted 6 lines · Leon Hwang
cd
tools/testing/selftests/bpf; ./test_progs -t tailcalls335/27 tailcalls/tailcall_bpf2bpf_hierarchy_freplace_1:OK 335/28 tailcalls/tailcall_bpf2bpf_hierarchy_freplace_2:OK 335 tailcalls:OKSummary: 1/28 PASSED, 0 SKIPPED, 0 FAILED
Quoted 8 lines
Quoted 2 lines
Signed-off-by Leon Hwang <[email protected]>---
Tbh, I don't think these tests are necessary.
Patch #2 already covers changes in patch #1.[...]
You are right.
Quoted 8 lines
I should provide the commit message to tell the reason why to add these two test cases:
In order to confirm tailcall in freplace is OK and won't be broken by patch of preventing tailcall infinite loop caused by freplace or other patches in the future, add two test cases to confirm that freplace is OK to tail call itself or other freplace prog, even if the target prog of freplace is a subprog and the subprog is called many times in its caller.
Not following.
What's the point of adding more tests when patch 2 covers the cases already?
Re: [PATCH bpf-next v6 3/3] selftests/bpf: Add cases to test tailcall in freplace
Quoted 26 lines · Alexei Starovoitov
Quoted 25 lines · Leon Hwang
Quoted 7 lines · Eduard Zingerman
Quoted 6 lines · Leon Hwang
cd
tools/testing/selftests/bpf; ./test_progs -t tailcalls335/27 tailcalls/tailcall_bpf2bpf_hierarchy_freplace_1:OK 335/28 tailcalls/tailcall_bpf2bpf_hierarchy_freplace_2:OK 335 tailcalls:OKSummary: 1/28 PASSED, 0 SKIPPED, 0 FAILED
Quoted 8 lines
Quoted 2 lines
Signed-off-by Leon Hwang <[email protected]>---
Tbh, I don't think these tests are necessary.
Patch #2 already covers changes in patch #1.[...]
You are right.
I should provide the commit message to tell the reason why to add these two test cases:
Quoted 8 lines
Quoted 5 lines
In order to confirm tailcall in freplace is OK and won't be broken by patch of preventing tailcall infinite loop caused by freplace or other patches in the future, add two test cases to confirm that freplace is OK to tail call itself or other freplace prog, even if the target prog of freplace is a subprog and the subprog is called many times in its caller.
Not following.
What's the point of adding more tests when patch 2 covers the cases already?
It's to test cases about tailcall in freplace.
But it seems unnecessary to add them. I'll drop this patch.
Thanks,
Leon
Re: [PATCH bpf-next v6 1/3] bpf: Prevent tailcall infinite loop caused by freplace
In reply to Alexei StarovoitovQuoted 163 lines · Alexei Starovoitov
Quoted 45 lines · Leon Hwang
This patch prevents an infinite loop issue caused by combination of tailcall and freplace.
For example:
tc_bpf2bpf.c:// SPDX-License-Identifier: GPL-2.0
\#include <
linux/bpf.h>
\#include <bpf/bpf_helpers.h>
__noinline
intsubprog_tc(struct __sk_buff *skb){ return skb->len * 2; }
SEC("tc")
intentry_tc(struct __sk_buff *skb){ return subprog_tc(skb); }char __license[]
SEC("license")= "GPL";
tailcall_freplace.c:// SPDX-License-Identifier: GPL-2.0
\#include <
linux/bpf.h>
\#include <bpf/bpf_helpers.h>struct { __uint(type, BPF_MAP_TYPE_PROG_ARRAY); __uint(max_entries, 1); __uint(key_size, sizeof(__u32)); __uint(value_size, sizeof(__u32)); } jmp_table SEC(".maps");int count = 0;
SEC("freplace")
intentry_freplace(struct __sk_buff *skb)Quoted 7 lines
{ count++; bpf_tail_call_static(skb, &jmp_table, 0); return count; }char __license[]
SEC("license")= "GPL";No need to put the whole selftest into commit log.
The below few paragraphs are enough:
Quoted 7 lines
The attach target of
entry_freplaceissubprog_tc, and the tail callee inentry_freplaceisentry_tc.Then, the infinite loop will be
entry_tc->subprog_tc->entry_freplace--tailcall->entry_tc, becausetail_call_cntinentry_freplacewill count from zero for every time ofentry_freplaceexecution. Kernel will panic, like:99% of this full dump below is nothing but noise.
Drop it. Above "kernel will panic" is enough.Quoted 91 lines
[ 15.310490] BUG: TASK stack guard page was hit at (____ptrval____) (stack is (____ptrval____)..(____ptrval____)) [ 15.310490] Oops: stack guard page: 0000 [#1] PREEMPT SMP NOPTI [ 15.310490] CPU: 1 PID: 89 Comm: test_progs Tainted: G OE 6.10.0-rc6-g026dcdae8d3e-dirty #72 [ 15.310490] Hardware name: QEMU Ubuntu 24.04 PC (i440FX + PIIX, 1996), BIOS 1.16.3-debian-1.16.3-2 04/01/2014 [ 15.310490] RIP: 0010:bpf_prog_3a140cef239a4b4f_subprog_tail+0x14/0x53 [ 15.310490] Code: cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc f3 0f 1e fa 0f 1f 44 00 00 0f 1f 00 55 48 89 e5 f3 0f 1e fa <50> 50 53 41 55 48 89 fb 49 bd 00 2a 46 82 98 9c ff ff 48 89 df 4c [ 15.310490] RSP: 0018:ffffb500c0aa0000 EFLAGS: 00000202 [ 15.310490] RAX: ffffb500c0aa0028 RBX: ffff9c98808b7e00 RCX: 0000000000008cb5 [ 15.310490] RDX: 0000000000000000 RSI: ffff9c9882462a00 RDI: ffff9c98808b7e00 [ 15.310490] RBP: ffffb500c0aa0000 R08: 0000000000000000 R09: 0000000000000000 [ 15.310490] R10: 0000000000000001 R11: 0000000000000000 R12: ffffb500c01af000 [ 15.310490] R13: ffffb500c01cd000 R14: 0000000000000000 R15: 0000000000000000 [ 15.310490] FS: 00007f133b665140(0000) GS:ffff9c98bbd00000(0000) knlGS:0000000000000000 [ 15.310490] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 15.310490] CR2: ffffb500c0a9fff8 CR3: 0000000102478000 CR4: 00000000000006f0 [ 15.310490] Call Trace: [ 15.310490] <#DF> [ 15.310490] ? die+0x36/0x90 [ 15.310490] ? handle_stack_overflow+0x4d/0x60 [ 15.310490] ? exc_double_fault+0x117/0x1a0 [ 15.310490] ? asm_exc_double_fault+0x23/0x30 [ 15.310490] ? bpf_prog_3a140cef239a4b4f_subprog_tail+0x14/0x53 [ 15.310490] </#DF> [ 15.310490] <TASK> [ 15.310490] bpf_prog_85781a698094722f_entry+0x4c/0x64 [ 15.310490] bpf_prog_1c515f389a9059b4_entry2+0x19/0x1b [ 15.310490] ... [ 15.310490] bpf_prog_85781a698094722f_entry+0x4c/0x64 [ 15.310490] bpf_prog_1c515f389a9059b4_entry2+0x19/0x1b [ 15.310490] bpf_test_run+0x210/0x370 [ 15.310490] ? bpf_test_run+0x128/0x370 [ 15.310490] bpf_prog_test_run_skb+0x388/0x7a0 [ 15.310490] __sys_bpf+0xdbf/0x2c40 [ 15.310490] ? clockevents_program_event+0x52/0xf0 [ 15.310490] ? lock_release+0xbf/0x290 [ 15.310490] __x64_sys_bpf+0x1e/0x30 [ 15.310490] do_syscall_64+0x68/0x140 [ 15.310490] entry_SYSCALL_64_after_hwframe+0x76/0x7e [ 15.310490] RIP: 0033:0x7f133b52725d [ 15.310490] Code: ff c3 66 2e 0f 1f 84 00 00 00 00 00 90 f3 0f 1e fa 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 8b 0d 8b bb 0d 00 f7 d8 64 89 01 48 [ 15.310490] RSP: 002b:00007ffddbc10258 EFLAGS: 00000206 ORIG_RAX: 0000000000000141 [ 15.310490] RAX: ffffffffffffffda RBX: 00007ffddbc10828 RCX: 00007f133b52725d [ 15.310490] RDX: 0000000000000050 RSI: 00007ffddbc102a0 RDI: 000000000000000a [ 15.310490] RBP: 00007ffddbc10270 R08: 0000000000000000 R09: 00007ffddbc102a0 [ 15.310490] R10: 0000000000000064 R11: 0000000000000206 R12: 0000000000000004 [ 15.310490] R13: 0000000000000000 R14: 0000558ec4c24890 R15: 00007f133b6ed000 [ 15.310490] </TASK> [ 15.310490] Modules linked in: bpf_testmod(OE) [ 15.310490] ---[ end trace 0000000000000000 ]--- [ 15.310490] RIP: 0010:bpf_prog_3a140cef239a4b4f_subprog_tail+0x14/0x53 [ 15.310490] Code: cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc f3 0f 1e fa 0f 1f 44 00 00 0f 1f 00 55 48 89 e5 f3 0f 1e fa <50> 50 53 41 55 48 89 fb 49 bd 00 2a 46 82 98 9c ff ff 48 89 df 4c [ 15.310490] RSP: 0018:ffffb500c0aa0000 EFLAGS: 00000202 [ 15.310490] RAX: ffffb500c0aa0028 RBX: ffff9c98808b7e00 RCX: 0000000000008cb5 [ 15.310490] RDX: 0000000000000000 RSI: ffff9c9882462a00 RDI: ffff9c98808b7e00 [ 15.310490] RBP: ffffb500c0aa0000 R08: 0000000000000000 R09: 0000000000000000 [ 15.310490] R10: 0000000000000001 R11: 0000000000000000 R12: ffffb500c01af000 [ 15.310490] R13: ffffb500c01cd000 R14: 0000000000000000 R15: 0000000000000000 [ 15.310490] FS: 00007f133b665140(0000) GS:ffff9c98bbd00000(0000) knlGS:0000000000000000 [ 15.310490] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 15.310490] CR2: ffffb500c0a9fff8 CR3: 0000000102478000 CR4: 00000000000006f0 [ 15.310490] Kernel panic - not syncing: Fatal exception in interrupt [ 15.310490] Kernel Offset: 0x30000000 from 0xffffffff81000000Quoted 1 line
(relocation range: 0xffffffff80000000-0xffffffffbfffffff)
Quoted 6 lines
Below paragraphs are almost ok, but pls use imperative language. Instead of "this patch prevents ..."
say "Fix the issue by preventing update of ext prog .."Consider using grammarly or chatgpt to make it less nerdy.
Got it. Thanks for your suggestion.
Quoted 138 lines
Quoted 138 lines
This patch prevents this panic by preventing updating extended prog to
prog_arraymap and preventing extending a prog, which has been updated toprog_arraymap, with freplace prog.If a prog or its subprog has been extended by freplace prog, the prog can not be updated to
prog_arraymap.If a prog has been updated to
prog_arraymap, it or its subprog can not be extended by freplace prog.BTW, fix a minor code style issue by replacing 8 spaces with a tab.
Reported-by kernel test robot <[email protected]>Signed-off-by Leon Hwang <[email protected]>--- include/linux/bpf.h | 21 ++++++++++++++++++++ kernel/bpf/arraymap.c | 23 +++++++++++++++++++++- kernel/bpf/core.c | 1 + kernel/bpf/syscall.c | 21 ++++++++++++++------ kernel/bpf/trampoline.c | 43 +++++++++++++++++++++++++++++++++++++++++ 5 files changed, 102 insertions(+), 7 deletions(-)include/linux/bpf.h +21
-0@@ -1294,6 +1294,12 @@ bool __bpf_dynptr_is_rdonly(const struct bpf_dynptr_kern *ptr);#ifdef CONFIG_BPF_JIT int bpf_trampoline_link_prog (struct bpf_tramp_link *link,struct bpf_trampoline *tr);int bpf_trampoline_unlink_prog (struct bpf_tramp_link *link,struct bpf_trampoline *tr); +int bpf_extension_link_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog); +int bpf_extension_unlink_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog);struct bpf_trampoline *bpf_trampoline_get (u64 key,struct bpf_attach_target_info *tgt_info);void bpf_trampoline_put (struct bpf_trampoline *tr);@@ -1383,6 +1389,18 @@ static inline int bpf_trampoline_unlink_prog(struct bpf_tramp_link *link, {return -ENOTSUPP ; } +static inline int bpf_extension_link_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog) +{ +return -ENOTSUPP ; +} +static inline int bpf_extension_unlink_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog) +{ +return -ENOTSUPP ; +}static inline struct bpf_trampoline *bpf_trampoline_get (u64 key,struct bpf_attach_target_info *tgt_info) {@@ -1483,6 +1501,9 @@ struct bpf_prog_aux {bool xdp_has_frags;bool exception_cb;bool exception_boundary; +bool is_extended;/* true if extended by freplace program */ +u64 prog_array_member_cnt;/* counts how many times as member of prog_array */ +struct mutex ext_mutex;/* mutex for is_extended and prog_array_member_cnt */ struct bpf_arena *arena;/* BTF_KIND_FUNC_PROTO for valid attach_btf_id */ const struct btf_type *attach_func_proto;kernel/bpf/arraymap.c +22
-1@@ -947,6 +947,7 @@ static void *prog_fd_array_get_ptr(struct bpf_map *map, struct file *map_file, int fd) {struct bpf_prog *prog =bpf_prog_get (fd); +bool is_extended;if (IS_ERR (prog))return prog;@@ -956,13 +957,33 @@ static void *prog_fd_array_get_ptr(struct bpf_map *map,return ERR_PTR (-EINVAL ); } +mutex_lock (&prog->aux->ext_mutex); + is_extended = prog->aux->is_extended; +if (!is_extended) + prog->aux->prog_array_member_cnt++; +mutex_unlock (&prog->aux->ext_mutex); +if (is_extended) { +/* Extended prog can not be tail callee. It's to prevent a +* potential infinite loop like: +* tail callee prog entry -> tail callee prog subprog -> +* freplace prog entry --tailcall-> tail callee prog entry. +*/ +bpf_prog_put (prog); +return ERR_PTR (-EBUSY ); + } +return prog; }static void prog_fd_array_put_ptr (struct bpf_map *map,void *ptr,bool need_defer) { +struct bpf_prog *prog = ptr; + +mutex_lock (&prog->aux->ext_mutex); + prog->aux->prog_array_member_cnt--; +mutex_unlock (&prog->aux->ext_mutex);/* bpf_prog is freed after one RCU or tasks trace grace period */ -bpf_prog_put (ptr); +bpf_prog_put (prog); }static u32 prog_fd_array_sys_lookup_elem (void *ptr)kernel/bpf/core.c +1
-0@@ -131,6 +131,7 @@ struct bpf_prog *bpf_prog_alloc_no_stats(unsigned int size, gfp_t gfp_extra_flagINIT_LIST_HEAD_RCU (&fp->aux->ksym_prefix.lnode);#endif mutex_init (&fp->aux->used_maps_mutex); +mutex_init (&fp->aux->ext_mutex);mutex_init (&fp->aux->dst_mutex);return fp;kernel/bpf/syscall.c +1
-0@@ -3212,15 +3212,21 @@ static void bpf_tracing_link_release(struct bpf_link *link) {struct bpf_tracing_link *tr_link = container_of(link, struct bpf_tracing_link, link.link); +struct bpf_prog *tgt_prog = tr_link->tgt_prog;
Quoted 14 lines
kernel/bpf/syscall.c static void bpf_tracing_link_release(struct bpf_link *link) · line 3223
Quoted 9 lines
kernel/bpf/syscall.c +7
-2-WARN_ON_ONCE (bpf_trampoline_unlink_prog (&tr_link->link, - tr_link->trampoline)); +if (link->prog->type ==BPF_PROG_TYPE_EXT ) +WARN_ON_ONCE (bpf_extension_unlink_prog (&tr_link->link, + tr_link->trampoline, + tgt_prog)); +else +WARN_ON_ONCE (bpf_trampoline_unlink_prog (&tr_link->link, + tr_link->trampoline));This early demux into two helpers looks odd.
I think it would be cleaner to add this logic tobpf_trampoline_unlink_prog()Just extend it with an extra prog argument.
No problem. I can extend bpf_trampoline_unlink_prog().
Quoted 23 lines
Quoted 23 lines
kernel/bpf/syscall.c +3
-3bpf_trampoline_put (tr_link->trampoline);/* tgt_prog is NULL if target is a kernel function */ -if (tr_link->tgt_prog) -bpf_prog_put (tr_link->tgt_prog); +if (tgt_prog) +bpf_prog_put (tgt_prog); }static void bpf_tracing_link_dealloc (struct bpf_link *link)@@ -3354,7 +3360,7 @@ static int bpf_tracing_prog_attach(struct bpf_prog *prog,* in prog->aux * * - if prog->aux->dst_trampoline is NULL, the program has already been -* attached to a target and its initial target was cleared (below) +* attached to a target and its initial target was cleared (below) * * - if tgt_prog != NULL, the caller specified tgt_prog_fd + * target_btf_id using the link_create API. @@ -3429,7 +3435,10 @@ static int bpf_tracing_prog_attach(struct bpf_prog *prog,if (err) goto out_unlock;
Quoted 8 lines
kernel/bpf/syscall.c static int bpf_tracing_prog_attach(struct bpf_prog *prog, · line 3441
Quoted 5 lines
kernel/bpf/syscall.c +4
-1- err =bpf_trampoline_link_prog (&link->link, tr); +if (prog->type ==BPF_PROG_TYPE_EXT ) + err =bpf_extension_link_prog (&link->link, tr, tgt_prog); +else + err =bpf_trampoline_link_prog (&link->link, tr);same here.
Ack.
Quoted 11 lines
Quoted 11 lines
kernel/bpf/syscall.c +0
-0if (err) {bpf_link_cleanup (&link_primer); link =NULL ;kernel/bpf/trampoline.c +0
-0@@ -580,6 +580,35 @@ int bpf_trampoline_link_prog(struct bpf_tramp_link *link, struct bpf_trampolinereturn err; }
Quoted 11 lines
kernel/bpf/trampoline.c int bpf_trampoline_link_prog(struct bpf_tramp_link *link, struct bpf_trampoline · line 590
Quoted 8 lines
kernel/bpf/trampoline.c +8
-0+int bpf_extension_link_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog) +{ +struct bpf_prog_aux *aux = tgt_prog->aux; +int err; + +mutex_lock (&aux->ext_mutex);pls use guard(mutex) as I suggested earlier.
Thanks very much to suggest it again.
guard(mutex) is new for me. And I can learn how to use it from guard(mutex)(&arena->lock).
Quoted 28 lines
Quoted 28 lines
kernel/bpf/trampoline.c +21
-0+if (aux->prog_array_member_cnt) { +/* Program extensions can not extend target prog when the target +* prog has been updated to any prog_array map as tail callee. +* It's to prevent a potential infinite loop like: +* tgt prog entry -> tgt prog subprog -> freplace prog entry +* --tailcall-> tgt prog entry. +*/ + err = -EBUSY ; + goto out_unlock; + } + + err =bpf_trampoline_link_prog (link, tr); +if (err) + goto out_unlock; + + aux->is_extended = true; +out_unlock: +mutex_unlock (&aux->ext_mutex); +return err; +} +static int __bpf_trampoline_unlink_prog (struct bpf_tramp_link *link,struct bpf_trampoline *tr) {enum bpf_tramp_prog_type kind;@@ -609,6 +638,20 @@ int bpf_trampoline_unlink_prog(struct bpf_tramp_link *link, struct bpf_trampolinreturn err; }
Quoted 14 lines
kernel/bpf/trampoline.c int bpf_trampoline_unlink_prog(struct bpf_tramp_link *link, struct bpf_trampolin · line 651
Quoted 11 lines
kernel/bpf/trampoline.c +11
-0+int bpf_extension_unlink_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog) +{ +struct bpf_prog_aux *aux = tgt_prog->aux; +int err; + +mutex_lock (&aux->ext_mutex); + err =bpf_trampoline_unlink_prog (link, tr); + aux->is_extended = false; +mutex_unlock (&aux->ext_mutex);same suggestions.
Ack.
Quoted 1 line
pw-bot: cr
Thanks,
Leon
Re: [PATCH bpf-next v6 1/3] bpf: Prevent tailcall infinite loop caused by freplace
In reply to Leon HwangQuoted 242 lines · Leon Hwang
This patch prevents an infinite loop issue caused by combination of tailcall and freplace.
For example:
tc_bpf2bpf.c:// SPDX-License-Identifier: GPL-2.0
\#include <
linux/bpf.h>
\#include <bpf/bpf_helpers.h>
__noinline
intsubprog_tc(struct __sk_buff *skb){ return skb->len * 2; }
SEC("tc")
intentry_tc(struct __sk_buff *skb){ return subprog_tc(skb); }char __license[]
SEC("license")= "GPL";
tailcall_freplace.c:// SPDX-License-Identifier: GPL-2.0
\#include <
linux/bpf.h>
\#include <bpf/bpf_helpers.h>struct { __uint(type, BPF_MAP_TYPE_PROG_ARRAY); __uint(max_entries, 1); __uint(key_size, sizeof(__u32)); __uint(value_size, sizeof(__u32)); } jmp_table SEC(".maps");int count = 0;
SEC("freplace")
intentry_freplace(struct __sk_buff *skb){ count++; bpf_tail_call_static(skb, &jmp_table, 0); return count; }char __license[]
SEC("license")= "GPL";The attach target of
entry_freplaceissubprog_tc, and the tail callee inentry_freplaceisentry_tc.Then, the infinite loop will be
entry_tc->subprog_tc->entry_freplace--tailcall->entry_tc, becausetail_call_cntinentry_freplacewill count from zero for every time ofentry_freplaceexecution. Kernel will panic, like:[ 15.310490] BUG: TASK stack guard page was hit at (____ptrval____) (stack is (____ptrval____)..(____ptrval____)) [ 15.310490] Oops: stack guard page: 0000 [#1] PREEMPT SMP NOPTI [ 15.310490] CPU: 1 PID: 89 Comm: test_progs Tainted: G OE 6.10.0-rc6-g026dcdae8d3e-dirty #72 [ 15.310490] Hardware name: QEMU Ubuntu 24.04 PC (i440FX + PIIX, 1996), BIOS 1.16.3-debian-1.16.3-2 04/01/2014 [ 15.310490] RIP: 0010:bpf_prog_3a140cef239a4b4f_subprog_tail+0x14/0x53 [ 15.310490] Code: cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc f3 0f 1e fa 0f 1f 44 00 00 0f 1f 00 55 48 89 e5 f3 0f 1e fa <50> 50 53 41 55 48 89 fb 49 bd 00 2a 46 82 98 9c ff ff 48 89 df 4c [ 15.310490] RSP: 0018:ffffb500c0aa0000 EFLAGS: 00000202 [ 15.310490] RAX: ffffb500c0aa0028 RBX: ffff9c98808b7e00 RCX: 0000000000008cb5 [ 15.310490] RDX: 0000000000000000 RSI: ffff9c9882462a00 RDI: ffff9c98808b7e00 [ 15.310490] RBP: ffffb500c0aa0000 R08: 0000000000000000 R09: 0000000000000000 [ 15.310490] R10: 0000000000000001 R11: 0000000000000000 R12: ffffb500c01af000 [ 15.310490] R13: ffffb500c01cd000 R14: 0000000000000000 R15: 0000000000000000 [ 15.310490] FS: 00007f133b665140(0000) GS:ffff9c98bbd00000(0000) knlGS:0000000000000000 [ 15.310490] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 15.310490] CR2: ffffb500c0a9fff8 CR3: 0000000102478000 CR4: 00000000000006f0 [ 15.310490] Call Trace: [ 15.310490] <#DF> [ 15.310490] ? die+0x36/0x90 [ 15.310490] ? handle_stack_overflow+0x4d/0x60 [ 15.310490] ? exc_double_fault+0x117/0x1a0 [ 15.310490] ? asm_exc_double_fault+0x23/0x30 [ 15.310490] ? bpf_prog_3a140cef239a4b4f_subprog_tail+0x14/0x53 [ 15.310490] </#DF> [ 15.310490] <TASK> [ 15.310490] bpf_prog_85781a698094722f_entry+0x4c/0x64 [ 15.310490] bpf_prog_1c515f389a9059b4_entry2+0x19/0x1b [ 15.310490] ... [ 15.310490] bpf_prog_85781a698094722f_entry+0x4c/0x64 [ 15.310490] bpf_prog_1c515f389a9059b4_entry2+0x19/0x1b [ 15.310490] bpf_test_run+0x210/0x370 [ 15.310490] ? bpf_test_run+0x128/0x370 [ 15.310490] bpf_prog_test_run_skb+0x388/0x7a0 [ 15.310490] __sys_bpf+0xdbf/0x2c40 [ 15.310490] ? clockevents_program_event+0x52/0xf0 [ 15.310490] ? lock_release+0xbf/0x290 [ 15.310490] __x64_sys_bpf+0x1e/0x30 [ 15.310490] do_syscall_64+0x68/0x140 [ 15.310490] entry_SYSCALL_64_after_hwframe+0x76/0x7e [ 15.310490] RIP: 0033:0x7f133b52725d [ 15.310490] Code: ff c3 66 2e 0f 1f 84 00 00 00 00 00 90 f3 0f 1e fa 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 8b 0d 8b bb 0d 00 f7 d8 64 89 01 48 [ 15.310490] RSP: 002b:00007ffddbc10258 EFLAGS: 00000206 ORIG_RAX: 0000000000000141 [ 15.310490] RAX: ffffffffffffffda RBX: 00007ffddbc10828 RCX: 00007f133b52725d [ 15.310490] RDX: 0000000000000050 RSI: 00007ffddbc102a0 RDI: 000000000000000a [ 15.310490] RBP: 00007ffddbc10270 R08: 0000000000000000 R09: 00007ffddbc102a0 [ 15.310490] R10: 0000000000000064 R11: 0000000000000206 R12: 0000000000000004 [ 15.310490] R13: 0000000000000000 R14: 0000558ec4c24890 R15: 00007f133b6ed000 [ 15.310490] </TASK> [ 15.310490] Modules linked in: bpf_testmod(OE) [ 15.310490] ---[ end trace 0000000000000000 ]--- [ 15.310490] RIP: 0010:bpf_prog_3a140cef239a4b4f_subprog_tail+0x14/0x53 [ 15.310490] Code: cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc f3 0f 1e fa 0f 1f 44 00 00 0f 1f 00 55 48 89 e5 f3 0f 1e fa <50> 50 53 41 55 48 89 fb 49 bd 00 2a 46 82 98 9c ff ff 48 89 df 4c [ 15.310490] RSP: 0018:ffffb500c0aa0000 EFLAGS: 00000202 [ 15.310490] RAX: ffffb500c0aa0028 RBX: ffff9c98808b7e00 RCX: 0000000000008cb5 [ 15.310490] RDX: 0000000000000000 RSI: ffff9c9882462a00 RDI: ffff9c98808b7e00 [ 15.310490] RBP: ffffb500c0aa0000 R08: 0000000000000000 R09: 0000000000000000 [ 15.310490] R10: 0000000000000001 R11: 0000000000000000 R12: ffffb500c01af000 [ 15.310490] R13: ffffb500c01cd000 R14: 0000000000000000 R15: 0000000000000000 [ 15.310490] FS: 00007f133b665140(0000) GS:ffff9c98bbd00000(0000) knlGS:0000000000000000 [ 15.310490] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 15.310490] CR2: ffffb500c0a9fff8 CR3: 0000000102478000 CR4: 00000000000006f0 [ 15.310490] Kernel panic - not syncing: Fatal exception in interrupt [ 15.310490] Kernel Offset: 0x30000000 from 0xffffffff81000000(relocation range: 0xffffffff80000000-0xffffffffbfffffff)
This patch prevents this panic by preventing updating extended prog to
prog_arraymap and preventing extending a prog, which has been updated toprog_arraymap, with freplace prog.If a prog or its subprog has been extended by freplace prog, the prog can not be updated to
prog_arraymap.If a prog has been updated to
prog_arraymap, it or its subprog can not be extended by freplace prog.BTW, fix a minor code style issue by replacing 8 spaces with a tab.
Reported-by kernel test robot <[email protected]>Signed-off-by Leon Hwang <[email protected]>--- include/linux/bpf.h | 21 ++++++++++++++++++++ kernel/bpf/arraymap.c | 23 +++++++++++++++++++++- kernel/bpf/core.c | 1 + kernel/bpf/syscall.c | 21 ++++++++++++++------ kernel/bpf/trampoline.c | 43 +++++++++++++++++++++++++++++++++++++++++ 5 files changed, 102 insertions(+), 7 deletions(-)include/linux/bpf.h +21
-0@@ -1294,6 +1294,12 @@ bool __bpf_dynptr_is_rdonly(const struct bpf_dynptr_kern *ptr);#ifdef CONFIG_BPF_JIT int bpf_trampoline_link_prog (struct bpf_tramp_link *link,struct bpf_trampoline *tr);int bpf_trampoline_unlink_prog (struct bpf_tramp_link *link,struct bpf_trampoline *tr); +int bpf_extension_link_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog); +int bpf_extension_unlink_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog);struct bpf_trampoline *bpf_trampoline_get (u64 key,struct bpf_attach_target_info *tgt_info);void bpf_trampoline_put (struct bpf_trampoline *tr);@@ -1383,6 +1389,18 @@ static inline int bpf_trampoline_unlink_prog(struct bpf_tramp_link *link, {return -ENOTSUPP ; } +static inline int bpf_extension_link_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog) +{ +return -ENOTSUPP ; +} +static inline int bpf_extension_unlink_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog) +{ +return -ENOTSUPP ; +}static inline struct bpf_trampoline *bpf_trampoline_get (u64 key,struct bpf_attach_target_info *tgt_info) {@@ -1483,6 +1501,9 @@ struct bpf_prog_aux {bool xdp_has_frags;bool exception_cb;bool exception_boundary; +bool is_extended;/* true if extended by freplace program */ +u64 prog_array_member_cnt;/* counts how many times as member of prog_array */ +struct mutex ext_mutex;/* mutex for is_extended and prog_array_member_cnt */ struct bpf_arena *arena;/* BTF_KIND_FUNC_PROTO for valid attach_btf_id */ const struct btf_type *attach_func_proto;kernel/bpf/arraymap.c +5
-0@@ -947,6 +947,7 @@ static void *prog_fd_array_get_ptr(struct bpf_map *map, struct file *map_file, int fd) {struct bpf_prog *prog =bpf_prog_get (fd); +bool is_extended;if (IS_ERR (prog))return prog;@@ -956,13 +957,33 @@ static void *prog_fd_array_get_ptr(struct bpf_map *map,return ERR_PTR (-EINVAL ); } +mutex_lock (&prog->aux->ext_mutex); + is_extended = prog->aux->is_extended; +if (!is_extended) + prog->aux->prog_array_member_cnt++;
kernel/bpf/arraymap.c static void *prog_fd_array_get_ptr(struct bpf_map *map, · line 973
Quoted 10 lines
kernel/bpf/arraymap.c +10
-0+mutex_unlock (&prog->aux->ext_mutex); +if (is_extended) { +/* Extended prog can not be tail callee. It's to prevent a +* potential infinite loop like: +* tail callee prog entry -> tail callee prog subprog -> +* freplace prog entry --tailcall-> tail callee prog entry. +*/ +bpf_prog_put (prog); +return ERR_PTR (-EBUSY ); + }
Sorry for the delay.
IIUC, extension prog should not be tailcalled independently, so an error should also be returned if prog->type == BPF_PROG_TYPE_EXT
Quoted 141 lines
kernel/bpf/arraymap.c +7
-1+return prog; }static void prog_fd_array_put_ptr (struct bpf_map *map,void *ptr,bool need_defer) { +struct bpf_prog *prog = ptr; + +mutex_lock (&prog->aux->ext_mutex); + prog->aux->prog_array_member_cnt--; +mutex_unlock (&prog->aux->ext_mutex);/* bpf_prog is freed after one RCU or tasks trace grace period */ -bpf_prog_put (ptr); +bpf_prog_put (prog); }static u32 prog_fd_array_sys_lookup_elem (void *ptr)kernel/bpf/core.c +1
-0@@ -131,6 +131,7 @@ struct bpf_prog *bpf_prog_alloc_no_stats(unsigned int size, gfp_t gfp_extra_flagINIT_LIST_HEAD_RCU (&fp->aux->ksym_prefix.lnode);#endif mutex_init (&fp->aux->used_maps_mutex); +mutex_init (&fp->aux->ext_mutex);mutex_init (&fp->aux->dst_mutex);return fp;kernel/bpf/syscall.c +15
-6@@ -3212,15 +3212,21 @@ static void bpf_tracing_link_release(struct bpf_link *link) {struct bpf_tracing_link *tr_link = container_of(link, struct bpf_tracing_link, link.link); +struct bpf_prog *tgt_prog = tr_link->tgt_prog; -WARN_ON_ONCE (bpf_trampoline_unlink_prog (&tr_link->link, - tr_link->trampoline)); +if (link->prog->type ==BPF_PROG_TYPE_EXT ) +WARN_ON_ONCE (bpf_extension_unlink_prog (&tr_link->link, + tr_link->trampoline, + tgt_prog)); +else +WARN_ON_ONCE (bpf_trampoline_unlink_prog (&tr_link->link, + tr_link->trampoline));bpf_trampoline_put (tr_link->trampoline);/* tgt_prog is NULL if target is a kernel function */ -if (tr_link->tgt_prog) -bpf_prog_put (tr_link->tgt_prog); +if (tgt_prog) +bpf_prog_put (tgt_prog); }static void bpf_tracing_link_dealloc (struct bpf_link *link)@@ -3354,7 +3360,7 @@ static int bpf_tracing_prog_attach(struct bpf_prog *prog,* in prog->aux * * - if prog->aux->dst_trampoline is NULL, the program has already been -* attached to a target and its initial target was cleared (below) +* attached to a target and its initial target was cleared (below) * * - if tgt_prog != NULL, the caller specified tgt_prog_fd + * target_btf_id using the link_create API. @@ -3429,7 +3435,10 @@ static int bpf_tracing_prog_attach(struct bpf_prog *prog,if (err) goto out_unlock; - err =bpf_trampoline_link_prog (&link->link, tr); +if (prog->type ==BPF_PROG_TYPE_EXT ) + err =bpf_extension_link_prog (&link->link, tr, tgt_prog); +else + err =bpf_trampoline_link_prog (&link->link, tr);if (err) {bpf_link_cleanup (&link_primer); link =NULL ;kernel/bpf/trampoline.c +43
-0@@ -580,6 +580,35 @@ int bpf_trampoline_link_prog(struct bpf_tramp_link *link, struct bpf_trampolinereturn err; } +int bpf_extension_link_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog) +{ +struct bpf_prog_aux *aux = tgt_prog->aux; +int err; + +mutex_lock (&aux->ext_mutex); +if (aux->prog_array_member_cnt) { +/* Program extensions can not extend target prog when the target +* prog has been updated to any prog_array map as tail callee. +* It's to prevent a potential infinite loop like: +* tgt prog entry -> tgt prog subprog -> freplace prog entry +* --tailcall-> tgt prog entry. +*/ + err = -EBUSY ; + goto out_unlock; + } + + err =bpf_trampoline_link_prog (link, tr); +if (err) + goto out_unlock; + + aux->is_extended = true; +out_unlock: +mutex_unlock (&aux->ext_mutex); +return err; +} +static int __bpf_trampoline_unlink_prog (struct bpf_tramp_link *link,struct bpf_trampoline *tr) {enum bpf_tramp_prog_type kind;@@ -609,6 +638,20 @@ int bpf_trampoline_unlink_prog(struct bpf_tramp_link *link, struct bpf_trampolinreturn err; } +int bpf_extension_unlink_prog (struct bpf_tramp_link *link, +struct bpf_trampoline *tr, +struct bpf_prog *tgt_prog) +{ +struct bpf_prog_aux *aux = tgt_prog->aux; +int err; + +mutex_lock (&aux->ext_mutex); + err =bpf_trampoline_unlink_prog (link, tr); + aux->is_extended = false; +mutex_unlock (&aux->ext_mutex); +return err; +} +#if defined(CONFIG_CGROUP_BPF ) && defined(CONFIG_BPF_LSM )static void bpf_shim_tramp_link_release (struct bpf_link *link) {
Re: [PATCH bpf-next v6 1/3] bpf: Prevent tailcall infinite loop caused by freplace
Quoted 264 lines · Xu Kuohai
Quoted 250 lines · Leon Hwang
This patch prevents an infinite loop issue caused by combination of tailcall
and freplace.For example:
tc_bpf2bpf.c:// SPDX-License-Identifier: GPL-2.0
\#include <
linux/bpf.h>
\#include <bpf/bpf_helpers.h>
__noinline
intsubprog_tc(struct __sk_buff *skb)
{
returnskb->len* 2;
}
SEC("tc")
intentry_tc(struct __sk_buff *skb)
{
returnsubprog_tc(skb);
}char __license[]
SEC("license")= "GPL";
tailcall_freplace.c:// SPDX-License-Identifier: GPL-2.0
\#include <
linux/bpf.h>
\#include <bpf/bpf_helpers.h>struct {
__uint(type,BPF_MAP_TYPE_PROG_ARRAY);
__uint(max_entries, 1);
__uint(key_size,sizeof(__u32));
__uint(value_size,sizeof(__u32));
}jmp_tableSEC(".maps");int count = 0;
SEC("freplace")
intentry_freplace(struct __sk_buff *skb)
{
count++;
bpf_tail_call_static(skb,&jmp_table, 0);
return count;
}char __license[]
SEC("license")= "GPL";The attach target of
entry_freplaceissubprog_tc, and the tail callee inentry_freplaceisentry_tc.Then, the infinite loop will be
entry_tc->subprog_tc->entry_freplace--tailcall->entry_tc, becausetail_call_cntinentry_freplacewill count from zero for every time ofentry_freplaceexecution. Kernel will panic, like:[ 15.310490] BUG: TASK stack guard page was hit at (
____ptrval____) (stack is (____ptrval____)..(____ptrval____))
[ 15.310490] Oops: stack guard page: 0000 [#1] PREEMPT SMP NOPTI [ 15.310490] CPU: 1 PID: 89 Comm:test_progsTainted: G OE 6.10.0-rc6-g026dcdae8d3e-dirty #72
[ 15.310490] Hardware name: QEMU Ubuntu 24.04 PC (i440FX + PIIX, 1996), BIOS 1.16.3-debian-1.16.3-2 04/01/2014
[ 15.310490] RIP: 0010:bpf_prog_3a140cef239a4b4f_subprog_tail+0x14/0x53 [ 15.310490] Code: cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc f3 0f 1e fa 0f 1f 44 00 00 0f 1f 00 55 48 89 e5 f3 0f 1e fa <50> 50 53 41 55 48 89 fb 49 bd 00 2a 46 82 98 9c ff ff 48 89 df 4c [ 15.310490] RSP: 0018:ffffb500c0aa0000 EFLAGS: 00000202
[ 15.310490] RAX:ffffb500c0aa0028RBX:ffff9c98808b7e00RCX:0000000000008cb5
[ 15.310490] RDX: 0000000000000000 RSI:ffff9c9882462a00RDI:ffff9c98808b7e00
[ 15.310490] RBP:ffffb500c0aa0000R08: 0000000000000000 R09:
0000000000000000
[ 15.310490] R10: 0000000000000001 R11: 0000000000000000 R12:ffffb500c01af000
[ 15.310490] R13:ffffb500c01cd000R14: 0000000000000000 R15:
0000000000000000
[ 15.310490] FS: 00007f133b665140(0000) GS:ffff9c98bbd00000(0000) knlGS:0000000000000000
[ 15.310490] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 15.310490] CR2:ffffb500c0a9fff8CR3: 0000000102478000 CR4:00000000000006f0
[ 15.310490] Call Trace:
[ 15.310490] <#DF>
[ 15.310490] ?die+0x36/0x90
[ 15.310490] ?handle_stack_overflow+0x4d/0x60
[ 15.310490] ?exc_double_fault+0x117/0x1a0
[ 15.310490] ?asm_exc_double_fault+0x23/0x30
[ 15.310490] ?bpf_prog_3a140cef239a4b4f_subprog_tail+0x14/0x53[ 15.310490] </#DF>
[ 15.310490] <TASK>
[ 15.310490]bpf_prog_85781a698094722f_entry+0x4c/0x64
[ 15.310490]bpf_prog_1c515f389a9059b4_entry2+0x19/0x1b
[ 15.310490] ...
[ 15.310490]bpf_prog_85781a698094722f_entry+0x4c/0x64
[ 15.310490]bpf_prog_1c515f389a9059b4_entry2+0x19/0x1b
[ 15.310490]bpf_test_run+0x210/0x370
[ 15.310490] ?bpf_test_run+0x128/0x370
[ 15.310490]bpf_prog_test_run_skb+0x388/0x7a0
[ 15.310490]__sys_bpf+0xdbf/0x2c40
[ 15.310490] ?clockevents_program_event+0x52/0xf0
[ 15.310490] ?lock_release+0xbf/0x290
[ 15.310490]__x64_sys_bpf+0x1e/0x30
[ 15.310490]do_syscall_64+0x68/0x140
[ 15.310490]entry_SYSCALL_64_after_hwframe+0x76/0x7e
[ 15.310490] RIP: 0033:0x7f133b52725d
[ 15.310490] Code: ff c3 66 2e 0f 1f 84 00 00 00 00 00 90 f3 0f 1e fa 48 89 f8 48 89 f7 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff 73 01 c3 48 8b 0d 8b bb 0d 00 f7 d8 64 89 01 48 [ 15.310490] RSP: 002b:00007ffddbc10258 EFLAGS: 00000206ORIG_RAX:
0000000000000141
[ 15.310490] RAX: ffffffffffffffda RBX:00007ffddbc10828RCX:00007f133b52725d
[ 15.310490] RDX: 0000000000000050 RSI:00007ffddbc102a0RDI:000000000000000a
[ 15.310490] RBP:00007ffddbc10270R08: 0000000000000000 R09:00007ffddbc102a0
[ 15.310490] R10: 0000000000000064 R11: 0000000000000206 R12:
0000000000000004
[ 15.310490] R13: 0000000000000000 R14:0000558ec4c24890R15:00007f133b6ed000
[ 15.310490] </TASK>
[ 15.310490] Modules linked in:bpf_testmod(OE)
[ 15.310490] ---[ end trace 0000000000000000 ]---
[ 15.310490] RIP: 0010:bpf_prog_3a140cef239a4b4f_subprog_tail+0x14/0x53 [ 15.310490] Code: cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc cc f3 0f 1e fa 0f 1f 44 00 00 0f 1f 00 55 48 89 e5 f3 0f 1e fa <50> 50 53 41 55 48 89 fb 49 bd 00 2a 46 82 98 9c ff ff 48 89 df 4c [ 15.310490] RSP: 0018:ffffb500c0aa0000 EFLAGS: 00000202
[ 15.310490] RAX:ffffb500c0aa0028RBX:ffff9c98808b7e00RCX:0000000000008cb5
[ 15.310490] RDX: 0000000000000000 RSI:ffff9c9882462a00RDI:ffff9c98808b7e00
[ 15.310490] RBP:ffffb500c0aa0000R08: 0000000000000000 R09:
0000000000000000
[ 15.310490] R10: 0000000000000001 R11: 0000000000000000 R12:ffffb500c01af000
[ 15.310490] R13:ffffb500c01cd000R14: 0000000000000000 R15:
0000000000000000
[ 15.310490] FS: 00007f133b665140(0000) GS:ffff9c98bbd00000(0000) knlGS:0000000000000000
[ 15.310490] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 [ 15.310490] CR2:ffffb500c0a9fff8CR3: 0000000102478000 CR4:00000000000006f0
[ 15.310490] Kernel panic - not syncing: Fatal exception in interrupt [ 15.310490] Kernel Offset:0x30000000from0xffffffff81000000(relocation range: 0xffffffff80000000-0xffffffffbfffffff)This patch prevents this panic by preventing updating extended prog to
prog_arraymap and preventing extending a prog, which has been updated toprog_arraymap, with freplace prog.If a prog or its subprog has been extended by freplace prog, the prog can not be updated to
prog_arraymap.If a prog has been updated to
prog_arraymap, it or its subprog can not be extended by freplace prog.BTW, fix a minor code style issue by replacing 8 spaces with a tab.
Reported-by kernel test robot <[email protected]>Signed-off-by Leon Hwang <[email protected]>---
include/linux/bpf.h | 21 ++++++++++++++++++++ kernel/bpf/arraymap.c | 23 +++++++++++++++++++++- kernel/bpf/core.c | 1 +
kernel/bpf/syscall.c | 21 ++++++++++++++------kernel/bpf/trampoline.c| 43 +++++++++++++++++++++++++++++++++++++++++5 files changed, 102 insertions(+), 7 deletions(-)include/linux/bpf.h +0
-0@@ -1294,6 +1294,12 @@ bool __bpf_dynptr_is_rdonly(const struct bpf_dynptr_kern *ptr); #ifdef CONFIG_BPF_JITint
bpf_trampoline_link_prog(struct bpf_tramp_link *link, struct bpf_trampoline *tr);
intbpf_trampoline_unlink_prog(struct bpf_tramp_link *link, struct bpf_trampoline *tr);include/linux/bpf.h +6
-0+int bpf_extension_link_prog (struct bpf_tramp_link *link, + struct bpf_trampoline *tr, + struct bpf_prog *tgt_prog); +int bpf_extension_unlink_prog (struct bpf_tramp_link *link, + struct bpf_trampoline *tr, + struct bpf_prog *tgt_prog);struct
bpf_trampoline*bpf_trampoline_get(u64 key, structbpf_attach_target_info*tgt_info); voidbpf_trampoline_put(struct bpf_trampoline *tr);include/linux/bpf.h +12
-0@@ -1383,6 +1389,18 @@ static inline int bpf_trampoline_unlink_prog(struct bpf_tramp_link *link, { return -ENOTSUPP; } +static inline int bpf_extension_link_prog (struct bpf_tramp_link *link, + struct bpf_trampoline *tr, + struct bpf_prog *tgt_prog) +{ + return -ENOTSUPP; +} +static inline int bpf_extension_unlink_prog (struct bpf_tramp_link *link, + struct bpf_trampoline *tr, + struct bpf_prog *tgt_prog) +{ + return -ENOTSUPP; +} static inline struct bpf_trampoline *bpf_trampoline_get(u64 key, struct bpf_attach_target_info *tgt_info){
include/linux/bpf.h +2
-0@@ -1483,6 +1501,9 @@ struct bpf_prog_aux { bool xdp_has_frags; bool exception_cb; bool exception_boundary; + bool is_extended; /* true if extended by freplace program */ + u64 prog_array_member_cnt; /* counts how many times as member of
prog_array*/
+ struct mutexext_mutex; /* mutex foris_extendedandprog_array_member_cnt*/
structbpf_arena*arena;
/*BTF_KIND_FUNC_PROTOfor validattach_btf_id*/ const structbtf_type*attach_func_proto;kernel/bpf/arraymap.c +4
-0@@ -947,6 +947,7 @@ static void *prog_fd_array_get_ptr(struct bpf_map *map, struct file *map_file, int fd) { struct bpf_prog *prog = bpf_prog_get(fd); + bool is_extended; if (IS_ERR(prog)) return prog;@@ -956,13 +957,33 @@ static void *prog_fd_array_get_ptr(struct bpf_map *map, return ERR_PTR(-EINVAL); } + mutex_lock(&prog->aux->ext_mutex); + is_extended = prog->aux->is_extended; + if (!is_extended) + prog->aux->prog_array_member_cnt++;kernel/bpf/arraymap.c static void *prog_fd_array_get_ptr(struct · line 973
Quoted 10 lines
kernel/bpf/arraymap.c +10
-0+ mutex_unlock(&prog->aux->ext_mutex); + if (is_extended) { + /* Extended prog can not be tail callee. It's to prevent a + * potential infinite loop like: + * tail callee prog entry -> tail callee prog subprog -> + * freplace prog entry --tailcall-> tail callee prog entry. + */ + bpf_prog_put(prog); + return ERR_PTR(-EBUSY); + }Sorry for the delay.
Quoted 3 lines
IIUC, extension prog should not be tailcalled independently, so an error should also be returned if
prog->type==BPF_PROG_TYPE_EXT
I think it's OK that freplace prog tail calls itself, see patch #3.
Thanks,
Leon