Skip to contentSkip to conversation

bpf: Fix tailcall infinite loop caused by freplace

PATCH Superseded Leon Hwang 4 participants 17 messages Oct 8, 2024 – Oct 10, 2024

Subsystems (4)

v6 of 8 Superseded Latest is v8 →

lore
Share & tools
lore

Leon Hwang

author
#0 lore raw

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
author
#1 lore raw

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
index 19d8ca8ac960f..213a68c59bdf7 100644
@@ -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
index 79660e3fca4c1..f9bd63a74eee7 100644
@@ -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
index 5e77c58e06010..233ea78f8f1bd 100644
@@ -131,6 +131,7 @@ struct bpf_prog *bpf_prog_alloc_no_stats(unsigned int size, gfp_t gfp_extra_flag
 	INIT_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
index a8f1808a1ca54..4a5a44bbb5f50 100644
@@ -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
maintainer Reviewed-by on v6 1/3
#2 lore raw

Re: [PATCH bpf-next v6 1/3] bpf: Prevent tailcall infinite loop caused by freplace

Quoted 2 lines · Leon Hwang

This patch prevents an infinite loop issue caused by combination of tailcall and freplace.

[...]

Quoted 4 lines

---

This seems correct as far as I can tell.

[...]

maintainer
#3 lore raw

Re: [PATCH bpf-next v6 1/3] bpf: Prevent tailcall infinite loop caused by freplace

In reply to Leon Hwang

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.

[...]

author
#4 lore raw

Re: [PATCH bpf-next v6 1/3] bpf: Prevent tailcall infinite loop caused by freplace

Quoted 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

#5 lore raw

Re: [PATCH bpf-next v6 1/3] bpf: Prevent tailcall infinite loop caused by freplace

In reply to Leon Hwang
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
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)

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_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:

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_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
index 19d8ca8ac960f..213a68c59bdf7 100644
@@ -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
index 79660e3fca4c1..f9bd63a74eee7 100644
@@ -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
index 5e77c58e06010..233ea78f8f1bd 100644
@@ -131,6 +131,7 @@ struct bpf_prog *bpf_prog_alloc_no_stats(unsigned int size, gfp_t gfp_extra_flag
        INIT_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
index a8f1808a1ca54..4a5a44bbb5f50 100644
@@ -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 -3
        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.

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 -0
        if (err) {
                bpf_link_cleanup(&link_primer);
                link = NULL;
kernel/bpf/trampoline.c +0 -0
index f8302a5ca400d..b14f56046ad4e 100644
@@ -580,6 +580,35 @@ int bpf_trampoline_link_prog(struct bpf_tramp_link *link, struct bpf_trampoline
        return 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_trampolin
        return 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

author
#6 lore raw

Re: [PATCH bpf-next v6 1/3] bpf: Prevent tailcall infinite loop caused by freplace

Quoted 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
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)

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_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:

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)

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_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
index 19d8ca8ac960f..213a68c59bdf7 100644
@@ -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
index 79660e3fca4c1..f9bd63a74eee7 100644
@@ -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
index 5e77c58e06010..233ea78f8f1bd 100644
@@ -131,6 +131,7 @@ struct bpf_prog *bpf_prog_alloc_no_stats(unsigned int size, gfp_t gfp_extra_flag
        INIT_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
index a8f1808a1ca54..4a5a44bbb5f50 100644
@@ -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 to bpf_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 -3
        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;
 
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 -0
        if (err) {
                bpf_link_cleanup(&link_primer);
                link = NULL;
kernel/bpf/trampoline.c +0 -0
index f8302a5ca400d..b14f56046ad4e 100644
@@ -580,6 +580,35 @@ int bpf_trampoline_link_prog(struct bpf_tramp_link *link, struct bpf_trampoline
        return 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_trampolin
        return 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

#7 lore raw

Re: [PATCH bpf-next v6 1/3] bpf: Prevent tailcall infinite loop caused by freplace

In reply to Leon Hwang
Quoted 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
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
index 19d8ca8ac960f..213a68c59bdf7 100644
@@ -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
index 79660e3fca4c1..f9bd63a74eee7 100644
@@ -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
index 5e77c58e06010..233ea78f8f1bd 100644
@@ -131,6 +131,7 @@ struct bpf_prog *bpf_prog_alloc_no_stats(unsigned int size, gfp_t gfp_extra_flag
  	INIT_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
index a8f1808a1ca54..4a5a44bbb5f50 100644
@@ -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
index f8302a5ca400d..b14f56046ad4e 100644
@@ -580,6 +580,35 @@ int bpf_trampoline_link_prog(struct bpf_tramp_link *link, struct bpf_trampoline
  	return 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_trampolin
  	return 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)
  {
author
#8 lore raw

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
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.

[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
index 19d8ca8ac960f..213a68c59bdf7 100644
@@ -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);

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, struct bpf_attach_target_info *tgt_info); void bpf_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 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 +4 -0
index 79660e3fca4c1..f9bd63a74eee7 100644
@@ -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

author
#9 lore raw

PATCH v6 2/3 selftests/bpf: Add a test case to confirm a tailcall infinite loop issue has been prevented

In reply to 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

---
 .../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
index 21c5a37846ade..fa3f3bb11b098 100644
@@ -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
index 8a0632c37839a..34f3c780194e4 100644
@@ -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
maintainer Acked-by on v6 2/3
#10 lore raw

Re: [PATCH bpf-next v6 2/3] selftests/bpf: Add a test case to confirm a tailcall infinite loop issue has been prevented

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 FAILED

Nit: commit message would be more useful with a small description of
the added test.

Quoted 3 lines

---

[...]

author
#11 lore raw

Re: [PATCH bpf-next v6 2/3] selftests/bpf: Add a test case to confirm a tailcall infinite loop issue has been prevented

Quoted 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 FAILED

Nit: 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

---

[...]

Thanks,
Leon

author
#12 lore raw

PATCH v6 3/3 selftests/bpf: Add cases to test tailcall in freplace

In reply to Leon Hwang

cd 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
index fa3f3bb11b098..0564ad6c9b288 100644
@@ -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
new file mode 100644
index 0000000000000..6f7c1fac9ddb7
@@ -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
index 34f3c780194e4..beacf60a52677 100644
@@ -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
maintainer
#13 lore raw

Re: [PATCH bpf-next v6 3/3] selftests/bpf: Add cases to test tailcall in freplace

Quoted 8 lines · Leon Hwang

cd 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

---

Tbh, I don't think these tests are necessary.
Patch #2 already covers changes in patch #1.

[...]

author
#14 lore raw

Re: [PATCH bpf-next v6 3/3] selftests/bpf: Add cases to test tailcall in freplace

Quoted 7 lines · Eduard Zingerman
Quoted 6 lines · Leon Hwang

cd 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

Quoted 8 lines
Quoted 2 lines

---

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

#15 lore raw

Re: [PATCH bpf-next v6 3/3] selftests/bpf: Add cases to test tailcall in freplace

Quoted 22 lines · Leon Hwang
Quoted 7 lines · Eduard Zingerman
Quoted 6 lines · Leon Hwang

cd 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

Quoted 8 lines
Quoted 2 lines

---

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?

author
#16 lore raw

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 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

Quoted 8 lines
Quoted 2 lines

---

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