Skip to contentSkip to conversation

bpf: add KF_SPIN_LOCK flag for kfuncs under bpf_spin_lock

PATCH Superseded Kaitao Cheng 4 participants 9 messages Aug 4

Subsystems (2)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 bpf: add KF_SPIN_LOCK flag for kfuncs under bpf_spin_lock

From: Kaitao Cheng <[email protected]>

Introduce the KF_SPIN_LOCK kfunc metadata flag in BTF so kfuncs may be explicitly marked as safe to call while holding bpf_spin_lock.

Allow kfuncs defined in kernel modules to be marked with KF_SPIN_LOCK.

Example: BTF_ID_FLAGS(func, $kfunc_name, KF_SPIN_LOCK)

---
 include/linux/btf.h   |  1 +
 kernel/bpf/verifier.c | 20 +++++++++++++++-----
 2 files changed, 16 insertions(+), 5 deletions(-)
include/linux/btf.h +1 -0
index c09b7994de4e..380dc10b6750 100644
@@ -79,6 +79,7 @@
 #define KF_ARENA_ARG1   (1 << 14) /* kfunc takes an arena pointer as its first argument */
 #define KF_ARENA_ARG2   (1 << 15) /* kfunc takes an arena pointer as its second argument */
 #define KF_IMPLICIT_ARGS (1 << 16) /* kfunc has implicit arguments supplied by the verifier */
+#define KF_SPIN_LOCK    (1 << 17) /* kfunc is allowed inside bpf_spin_lock-ed region */
 
 /*
  * Tag marking a kernel function as a kfunc. This is meant to minimize the
kernel/bpf/verifier.c +15 -5
index 7aa47342dc65..9f3feba3c2fe 100644
@@ -11657,11 +11657,21 @@ static bool is_bpf_stream_kfunc(u32 btf_id)
 	       btf_id == special_kfunc_list[KF_bpf_stream_print_stack];
 }
 
-static bool kfunc_spin_allowed(u32 btf_id)
+static bool kfunc_spin_allowed(struct bpf_verifier_env *env, s32 func_id, s16 offset)
 {
-	return is_bpf_graph_api_kfunc(btf_id) || is_bpf_iter_num_api_kfunc(btf_id) ||
-	       is_bpf_res_spin_lock_kfunc(btf_id) || is_bpf_arena_kfunc(btf_id) ||
-	       is_bpf_stream_kfunc(btf_id);
+	struct bpf_kfunc_meta kfunc;
+	int err;
+
+	if (is_bpf_graph_api_kfunc(func_id) || is_bpf_iter_num_api_kfunc(func_id) ||
+	    is_bpf_res_spin_lock_kfunc(func_id) || is_bpf_arena_kfunc(func_id) ||
+	    is_bpf_stream_kfunc(func_id))
+		return true;
+
+	err = fetch_kfunc_meta(env, func_id, offset, &kfunc);
+	if (err || !kfunc.flags)
+		return false;
+
+	return *kfunc.flags & KF_SPIN_LOCK;
 }
 
 static bool is_sync_callback_calling_kfunc(u32 btf_id)
@@ -17289,7 +17299,7 @@ static int do_check_insn(struct bpf_verifier_env *env, bool *do_print_state)
 				     insn->imm != BPF_FUNC_spin_unlock &&
 				     insn->imm != BPF_FUNC_kptr_xchg) ||
 				    (insn->src_reg == BPF_PSEUDO_KFUNC_CALL &&
-				     (insn->off != 0 || !kfunc_spin_allowed(insn->imm)))) {
+				     !kfunc_spin_allowed(env, insn->imm, insn->off))) {
 					verbose(env,
 						"function calls are not allowed while holding a lock\n");
 					return -EINVAL;
Signature · 1 line
2.50.1 (Apple Git-155)
#1 lore raw
Quoted 58 lines · Kaitao Cheng

From: Kaitao Cheng <[email protected]>

Introduce the KF_SPIN_LOCK kfunc metadata flag in BTF so kfuncs may be explicitly marked as safe to call while holding bpf_spin_lock.

Allow kfuncs defined in kernel modules to be marked with KF_SPIN_LOCK.

Example: BTF_ID_FLAGS(func, $kfunc_name, KF_SPIN_LOCK)

---
 include/linux/btf.h   |  1 +
 kernel/bpf/verifier.c | 20 +++++++++++++++-----
 2 files changed, 16 insertions(+), 5 deletions(-)
include/linux/btf.h +1 -0
index c09b7994de4e..380dc10b6750 100644
@@ -79,6 +79,7 @@
 #define KF_ARENA_ARG1   (1 << 14) /* kfunc takes an arena pointer as its first argument */
 #define KF_ARENA_ARG2   (1 << 15) /* kfunc takes an arena pointer as its second argument */
 #define KF_IMPLICIT_ARGS (1 << 16) /* kfunc has implicit arguments supplied by the verifier */
+#define KF_SPIN_LOCK    (1 << 17) /* kfunc is allowed inside bpf_spin_lock-ed region */
 
 /*
  * Tag marking a kernel function as a kfunc. This is meant to minimize the
kernel/bpf/verifier.c +14 -4
index 7aa47342dc65..9f3feba3c2fe 100644
@@ -11657,11 +11657,21 @@ static bool is_bpf_stream_kfunc(u32 btf_id)
 	       btf_id == special_kfunc_list[KF_bpf_stream_print_stack];
 }
 
-static bool kfunc_spin_allowed(u32 btf_id)
+static bool kfunc_spin_allowed(struct bpf_verifier_env *env, s32 func_id, s16 offset)
 {
-	return is_bpf_graph_api_kfunc(btf_id) || is_bpf_iter_num_api_kfunc(btf_id) ||
-	       is_bpf_res_spin_lock_kfunc(btf_id) || is_bpf_arena_kfunc(btf_id) ||
-	       is_bpf_stream_kfunc(btf_id);
+	struct bpf_kfunc_meta kfunc;
+	int err;
+
+	if (is_bpf_graph_api_kfunc(func_id) || is_bpf_iter_num_api_kfunc(func_id) ||
+	    is_bpf_res_spin_lock_kfunc(func_id) || is_bpf_arena_kfunc(func_id) ||
+	    is_bpf_stream_kfunc(func_id))
+		return true;
+
+	err = fetch_kfunc_meta(env, func_id, offset, &kfunc);
+	if (err || !kfunc.flags)
+		return false;
+
+	return *kfunc.flags & KF_SPIN_LOCK;
 }
 
 static bool is_sync_callback_calling_kfunc(u32 btf_id)

kernel/bpf/verifier.c static int do_check_insn(struct bpf_verifier_env *env, bool *do_print_state) · line 17305

Quoted 8 lines
kernel/bpf/verifier.c +1 -1
@@ -17289,7 +17299,7 @@ static int do_check_insn(struct bpf_verifier_env *env, bool *do_print_state)
 				     insn->imm != BPF_FUNC_spin_unlock &&
 				     insn->imm != BPF_FUNC_kptr_xchg) ||
 				    (insn->src_reg == BPF_PSEUDO_KFUNC_CALL &&
-				     (insn->off != 0 || !kfunc_spin_allowed(insn->imm)))) {
+				     !kfunc_spin_allowed(env, insn->imm, insn->off))) {
 					verbose(env,
 						"function calls are not allowed while holding a lock\n");
 					return -EINVAL;

Why not apply it to all of the existing kfuncs? Also, use [PATCH bpf-next] subject.

pw-bot: cr

#2 lore raw
Quoted 57 lines · Kumar Kartikeya Dwivedi
Quoted 56 lines · Kaitao Cheng

From: Kaitao Cheng <[email protected]>

Introduce the KF_SPIN_LOCK kfunc metadata flag in BTF so kfuncs may be explicitly marked as safe to call while holding bpf_spin_lock.

Allow kfuncs defined in kernel modules to be marked with KF_SPIN_LOCK.

Example: BTF_ID_FLAGS(func, $kfunc_name, KF_SPIN_LOCK)

---
 include/linux/btf.h   |  1 +
 kernel/bpf/verifier.c | 20 +++++++++++++++-----
 2 files changed, 16 insertions(+), 5 deletions(-)
include/linux/btf.h +1 -0
index c09b7994de4e..380dc10b6750 100644
@@ -79,6 +79,7 @@
 #define KF_ARENA_ARG1   (1 << 14) /* kfunc takes an arena pointer as its first argument */
 #define KF_ARENA_ARG2   (1 << 15) /* kfunc takes an arena pointer as its second argument */
 #define KF_IMPLICIT_ARGS (1 << 16) /* kfunc has implicit arguments supplied by the verifier */
+#define KF_SPIN_LOCK    (1 << 17) /* kfunc is allowed inside bpf_spin_lock-ed region */
 
 /*
  * Tag marking a kernel function as a kfunc. This is meant to minimize the
kernel/bpf/verifier.c +14 -4
index 7aa47342dc65..9f3feba3c2fe 100644
@@ -11657,11 +11657,21 @@ static bool is_bpf_stream_kfunc(u32 btf_id)
 	       btf_id == special_kfunc_list[KF_bpf_stream_print_stack];
 }
 
-static bool kfunc_spin_allowed(u32 btf_id)
+static bool kfunc_spin_allowed(struct bpf_verifier_env *env, s32 func_id, s16 offset)
 {
-	return is_bpf_graph_api_kfunc(btf_id) || is_bpf_iter_num_api_kfunc(btf_id) ||
-	       is_bpf_res_spin_lock_kfunc(btf_id) || is_bpf_arena_kfunc(btf_id) ||
-	       is_bpf_stream_kfunc(btf_id);
+	struct bpf_kfunc_meta kfunc;
+	int err;
+
+	if (is_bpf_graph_api_kfunc(func_id) || is_bpf_iter_num_api_kfunc(func_id) ||
+	    is_bpf_res_spin_lock_kfunc(func_id) || is_bpf_arena_kfunc(func_id) ||
+	    is_bpf_stream_kfunc(func_id))
+		return true;
+
+	err = fetch_kfunc_meta(env, func_id, offset, &kfunc);
+	if (err || !kfunc.flags)
+		return false;
+
+	return *kfunc.flags & KF_SPIN_LOCK;
 }
 
Quoted 12 lines

kernel/bpf/verifier.c static int do_check_insn(struct bpf_verifier_env *env, bool *do_print_state) · line 17305

Quoted 10 lines
kernel/bpf/verifier.c +1 -1
 static bool is_sync_callback_calling_kfunc(u32 btf_id)
@@ -17289,7 +17299,7 @@ static int do_check_insn(struct bpf_verifier_env *env, bool *do_print_state)
 				     insn->imm != BPF_FUNC_spin_unlock &&
 				     insn->imm != BPF_FUNC_kptr_xchg) ||
 				    (insn->src_reg == BPF_PSEUDO_KFUNC_CALL &&
-				     (insn->off != 0 || !kfunc_spin_allowed(insn->imm)))) {
+				     !kfunc_spin_allowed(env, insn->imm, insn->off))) {
 					verbose(env,
 						"function calls are not allowed while holding a lock\n");
 					return -EINVAL;

Why not apply it to all of the existing kfuncs? Also, use [PATCH bpf-next] subject.

I do not think all kfuncs are suitable for the KF_SPIN_LOCK context. Kfuncs marked with KF_SLEEPABLE are an obvious example. Developers should add KF_SPIN_LOCK with great care and ensure that the kfunc does not sleep and is safe to call in atomic context; otherwise, it could easily introduce deadlocks.

However, the kfuncs explicitly allowed by kfunc_spin_allowed(), such as those covered by is_bpf_graph_api_kfunc, is_bpf_iter_num_api_kfunc, is_bpf_res_spin_lock_kfunc, is_bpf_arena_kfunc and is_bpf_stream_kfunc, can be marked with KF_SPIN_LOCK. We can then simplify kfunc_spin_allowed() to rely solely on the flag.

Signature · 2 lines
Thanks
Kaitao Cheng
#3 lore raw
Quoted 77 lines · Kaitao Cheng
Quoted 57 lines · Kumar Kartikeya Dwivedi
Quoted 56 lines · Kaitao Cheng

From: Kaitao Cheng <[email protected]>

Introduce the KF_SPIN_LOCK kfunc metadata flag in BTF so kfuncs may be explicitly marked as safe to call while holding bpf_spin_lock.

Allow kfuncs defined in kernel modules to be marked with KF_SPIN_LOCK.

Example: BTF_ID_FLAGS(func, $kfunc_name, KF_SPIN_LOCK)

---
 include/linux/btf.h   |  1 +
 kernel/bpf/verifier.c | 20 +++++++++++++++-----
 2 files changed, 16 insertions(+), 5 deletions(-)
include/linux/btf.h +1 -0
index c09b7994de4e..380dc10b6750 100644
@@ -79,6 +79,7 @@
 #define KF_ARENA_ARG1   (1 << 14) /* kfunc takes an arena pointer as its first argument */
 #define KF_ARENA_ARG2   (1 << 15) /* kfunc takes an arena pointer as its second argument */
 #define KF_IMPLICIT_ARGS (1 << 16) /* kfunc has implicit arguments supplied by the verifier */
+#define KF_SPIN_LOCK    (1 << 17) /* kfunc is allowed inside bpf_spin_lock-ed region */
 
 /*
  * Tag marking a kernel function as a kfunc. This is meant to minimize the
kernel/bpf/verifier.c +14 -4
index 7aa47342dc65..9f3feba3c2fe 100644
@@ -11657,11 +11657,21 @@ static bool is_bpf_stream_kfunc(u32 btf_id)
 	       btf_id == special_kfunc_list[KF_bpf_stream_print_stack];
 }
 
-static bool kfunc_spin_allowed(u32 btf_id)
+static bool kfunc_spin_allowed(struct bpf_verifier_env *env, s32 func_id, s16 offset)
 {
-	return is_bpf_graph_api_kfunc(btf_id) || is_bpf_iter_num_api_kfunc(btf_id) ||
-	       is_bpf_res_spin_lock_kfunc(btf_id) || is_bpf_arena_kfunc(btf_id) ||
-	       is_bpf_stream_kfunc(btf_id);
+	struct bpf_kfunc_meta kfunc;
+	int err;
+
+	if (is_bpf_graph_api_kfunc(func_id) || is_bpf_iter_num_api_kfunc(func_id) ||
+	    is_bpf_res_spin_lock_kfunc(func_id) || is_bpf_arena_kfunc(func_id) ||
+	    is_bpf_stream_kfunc(func_id))
+		return true;
+
+	err = fetch_kfunc_meta(env, func_id, offset, &kfunc);
+	if (err || !kfunc.flags)
+		return false;
+
+	return *kfunc.flags & KF_SPIN_LOCK;
 }
 
Quoted 12 lines

kernel/bpf/verifier.c static int do_check_insn(struct bpf_verifier_env *env, bool *do_print_state) · line 17305

Quoted 10 lines
kernel/bpf/verifier.c +1 -1
 static bool is_sync_callback_calling_kfunc(u32 btf_id)
@@ -17289,7 +17299,7 @@ static int do_check_insn(struct bpf_verifier_env *env, bool *do_print_state)
 				     insn->imm != BPF_FUNC_spin_unlock &&
 				     insn->imm != BPF_FUNC_kptr_xchg) ||
 				    (insn->src_reg == BPF_PSEUDO_KFUNC_CALL &&
-				     (insn->off != 0 || !kfunc_spin_allowed(insn->imm)))) {
+				     !kfunc_spin_allowed(env, insn->imm, insn->off))) {
 					verbose(env,
 						"function calls are not allowed while holding a lock\n");
 					return -EINVAL;

Why not apply it to all of the existing kfuncs? Also, use [PATCH bpf-next] subject.

I do not think all kfuncs are suitable for the KF_SPIN_LOCK context. Kfuncs marked with KF_SLEEPABLE are an obvious example. Developers should add KF_SPIN_LOCK with great care and ensure that the kfunc does not sleep and is safe to call in atomic context; otherwise, it could easily introduce deadlocks.

Quoted 5 lines

However, the kfuncs explicitly allowed by kfunc_spin_allowed(), such as those covered by is_bpf_graph_api_kfunc, is_bpf_iter_num_api_kfunc, is_bpf_res_spin_lock_kfunc, is_bpf_arena_kfunc and is_bpf_stream_kfunc, can be marked with KF_SPIN_LOCK. We can then simplify kfunc_spin_allowed() to rely solely on the flag.

Yes, of course. I meant those that we maintain as a list in the verifier. KF_SPIN_LOCK is not a very optimal name. Should we do KF_ALLOWED_IN_LOCK_CS? A bit verbose but better captures the intended meaning.

#4 lore raw
Quoted 84 lines · Kumar Kartikeya Dwivedi
Quoted 77 lines · Kaitao Cheng
Quoted 57 lines · Kumar Kartikeya Dwivedi
Quoted 56 lines · Kaitao Cheng

From: Kaitao Cheng <[email protected]>

Introduce the KF_SPIN_LOCK kfunc metadata flag in BTF so kfuncs may be explicitly marked as safe to call while holding bpf_spin_lock.

Allow kfuncs defined in kernel modules to be marked with KF_SPIN_LOCK.

Example: BTF_ID_FLAGS(func, $kfunc_name, KF_SPIN_LOCK)

---
 include/linux/btf.h   |  1 +
 kernel/bpf/verifier.c | 20 +++++++++++++++-----
 2 files changed, 16 insertions(+), 5 deletions(-)
include/linux/btf.h +1 -0
index c09b7994de4e..380dc10b6750 100644
@@ -79,6 +79,7 @@
 #define KF_ARENA_ARG1   (1 << 14) /* kfunc takes an arena pointer as its first argument */
 #define KF_ARENA_ARG2   (1 << 15) /* kfunc takes an arena pointer as its second argument */
 #define KF_IMPLICIT_ARGS (1 << 16) /* kfunc has implicit arguments supplied by the verifier */
+#define KF_SPIN_LOCK    (1 << 17) /* kfunc is allowed inside bpf_spin_lock-ed region */
 
 /*
  * Tag marking a kernel function as a kfunc. This is meant to minimize the
kernel/bpf/verifier.c +14 -4
index 7aa47342dc65..9f3feba3c2fe 100644
@@ -11657,11 +11657,21 @@ static bool is_bpf_stream_kfunc(u32 btf_id)
 	       btf_id == special_kfunc_list[KF_bpf_stream_print_stack];
 }
 
-static bool kfunc_spin_allowed(u32 btf_id)
+static bool kfunc_spin_allowed(struct bpf_verifier_env *env, s32 func_id, s16 offset)
 {
-	return is_bpf_graph_api_kfunc(btf_id) || is_bpf_iter_num_api_kfunc(btf_id) ||
-	       is_bpf_res_spin_lock_kfunc(btf_id) || is_bpf_arena_kfunc(btf_id) ||
-	       is_bpf_stream_kfunc(btf_id);
+	struct bpf_kfunc_meta kfunc;
+	int err;
+
+	if (is_bpf_graph_api_kfunc(func_id) || is_bpf_iter_num_api_kfunc(func_id) ||
+	    is_bpf_res_spin_lock_kfunc(func_id) || is_bpf_arena_kfunc(func_id) ||
+	    is_bpf_stream_kfunc(func_id))
+		return true;
+
+	err = fetch_kfunc_meta(env, func_id, offset, &kfunc);
+	if (err || !kfunc.flags)
+		return false;
+
+	return *kfunc.flags & KF_SPIN_LOCK;
 }
 
Quoted 12 lines

kernel/bpf/verifier.c static int do_check_insn(struct bpf_verifier_env *env, bool *do_print_state) · line 17305

Quoted 10 lines
kernel/bpf/verifier.c +1 -1
 static bool is_sync_callback_calling_kfunc(u32 btf_id)
@@ -17289,7 +17299,7 @@ static int do_check_insn(struct bpf_verifier_env *env, bool *do_print_state)
 				     insn->imm != BPF_FUNC_spin_unlock &&
 				     insn->imm != BPF_FUNC_kptr_xchg) ||
 				    (insn->src_reg == BPF_PSEUDO_KFUNC_CALL &&
-				     (insn->off != 0 || !kfunc_spin_allowed(insn->imm)))) {
+				     !kfunc_spin_allowed(env, insn->imm, insn->off))) {
 					verbose(env,
 						"function calls are not allowed while holding a lock\n");
 					return -EINVAL;

Why not apply it to all of the existing kfuncs? Also, use [PATCH bpf-next] subject.

I do not think all kfuncs are suitable for the KF_SPIN_LOCK context. Kfuncs marked with KF_SLEEPABLE are an obvious example. Developers should add KF_SPIN_LOCK with great care and ensure that the kfunc does not sleep and is safe to call in atomic context; otherwise, it could easily introduce deadlocks.

Quoted 5 lines

However, the kfuncs explicitly allowed by kfunc_spin_allowed(), such as those covered by is_bpf_graph_api_kfunc, is_bpf_iter_num_api_kfunc, is_bpf_res_spin_lock_kfunc, is_bpf_arena_kfunc and is_bpf_stream_kfunc, can be marked with KF_SPIN_LOCK. We can then simplify kfunc_spin_allowed() to rely solely on the flag.

Quoted 3 lines

Yes, of course. I meant those that we maintain as a list in the verifier. KF_SPIN_LOCK is not a very optimal name. Should we do KF_ALLOWED_IN_LOCK_CS? A bit verbose but better captures the intended meaning.

The existing KF_* flag names are generally concise, so a much longer name feels somewhat out of place. I would also prefer the name to preserve the full spin_lock semantics, since "lock" can refer to many different lock types, such as mutex.

Alternatively, following the naming of GFP_ATOMIC, could we call it KF_ATOMIC?

Signature · 2 lines
Thanks
Kaitao Cheng
#5 lore raw
Quoted 89 lines · Kaitao Cheng
Quoted 84 lines · Kumar Kartikeya Dwivedi
Quoted 77 lines · Kaitao Cheng
Quoted 57 lines · Kumar Kartikeya Dwivedi
Quoted 56 lines · Kaitao Cheng

From: Kaitao Cheng <[email protected]>

Introduce the KF_SPIN_LOCK kfunc metadata flag in BTF so kfuncs may be explicitly marked as safe to call while holding bpf_spin_lock.

Allow kfuncs defined in kernel modules to be marked with KF_SPIN_LOCK.

Example: BTF_ID_FLAGS(func, $kfunc_name, KF_SPIN_LOCK)

---
 include/linux/btf.h   |  1 +
 kernel/bpf/verifier.c | 20 +++++++++++++++-----
 2 files changed, 16 insertions(+), 5 deletions(-)
include/linux/btf.h +1 -0
index c09b7994de4e..380dc10b6750 100644
@@ -79,6 +79,7 @@
 #define KF_ARENA_ARG1   (1 << 14) /* kfunc takes an arena pointer as its first argument */
 #define KF_ARENA_ARG2   (1 << 15) /* kfunc takes an arena pointer as its second argument */
 #define KF_IMPLICIT_ARGS (1 << 16) /* kfunc has implicit arguments supplied by the verifier */
+#define KF_SPIN_LOCK    (1 << 17) /* kfunc is allowed inside bpf_spin_lock-ed region */
 
 /*
  * Tag marking a kernel function as a kfunc. This is meant to minimize the
kernel/bpf/verifier.c +14 -4
index 7aa47342dc65..9f3feba3c2fe 100644
@@ -11657,11 +11657,21 @@ static bool is_bpf_stream_kfunc(u32 btf_id)
 	       btf_id == special_kfunc_list[KF_bpf_stream_print_stack];
 }
 
-static bool kfunc_spin_allowed(u32 btf_id)
+static bool kfunc_spin_allowed(struct bpf_verifier_env *env, s32 func_id, s16 offset)
 {
-	return is_bpf_graph_api_kfunc(btf_id) || is_bpf_iter_num_api_kfunc(btf_id) ||
-	       is_bpf_res_spin_lock_kfunc(btf_id) || is_bpf_arena_kfunc(btf_id) ||
-	       is_bpf_stream_kfunc(btf_id);
+	struct bpf_kfunc_meta kfunc;
+	int err;
+
+	if (is_bpf_graph_api_kfunc(func_id) || is_bpf_iter_num_api_kfunc(func_id) ||
+	    is_bpf_res_spin_lock_kfunc(func_id) || is_bpf_arena_kfunc(func_id) ||
+	    is_bpf_stream_kfunc(func_id))
+		return true;
+
+	err = fetch_kfunc_meta(env, func_id, offset, &kfunc);
+	if (err || !kfunc.flags)
+		return false;
+
+	return *kfunc.flags & KF_SPIN_LOCK;
 }
 
Quoted 12 lines

kernel/bpf/verifier.c static int do_check_insn(struct bpf_verifier_env *env, bool *do_print_state) · line 17305

Quoted 10 lines
kernel/bpf/verifier.c +1 -1
 static bool is_sync_callback_calling_kfunc(u32 btf_id)
@@ -17289,7 +17299,7 @@ static int do_check_insn(struct bpf_verifier_env *env, bool *do_print_state)
 				     insn->imm != BPF_FUNC_spin_unlock &&
 				     insn->imm != BPF_FUNC_kptr_xchg) ||
 				    (insn->src_reg == BPF_PSEUDO_KFUNC_CALL &&
-				     (insn->off != 0 || !kfunc_spin_allowed(insn->imm)))) {
+				     !kfunc_spin_allowed(env, insn->imm, insn->off))) {
 					verbose(env,
 						"function calls are not allowed while holding a lock\n");
 					return -EINVAL;

Why not apply it to all of the existing kfuncs? Also, use [PATCH bpf-next] subject.

I do not think all kfuncs are suitable for the KF_SPIN_LOCK context. Kfuncs marked with KF_SLEEPABLE are an obvious example. Developers should add KF_SPIN_LOCK with great care and ensure that the kfunc does not sleep and is safe to call in atomic context; otherwise, it could easily introduce deadlocks.

Quoted 5 lines

However, the kfuncs explicitly allowed by kfunc_spin_allowed(), such as those covered by is_bpf_graph_api_kfunc, is_bpf_iter_num_api_kfunc, is_bpf_res_spin_lock_kfunc, is_bpf_arena_kfunc and is_bpf_stream_kfunc, can be marked with KF_SPIN_LOCK. We can then simplify kfunc_spin_allowed() to rely solely on the flag.

Quoted 3 lines

Yes, of course. I meant those that we maintain as a list in the verifier. KF_SPIN_LOCK is not a very optimal name. Should we do KF_ALLOWED_IN_LOCK_CS? A bit verbose but better captures the intended meaning.

Quoted 6 lines

The existing KF_* flag names are generally concise, so a much longer name feels somewhat out of place. I would also prefer the name to preserve the full spin_lock semantics, since "lock" can refer to many different lock types, such as mutex.

Alternatively, following the naming of GFP_ATOMIC, could we call it KF_ATOMIC?

I think that is also confusing, every kfunc is allowed in atomic context in general. E.g. bpf_map_update_elem() in spin lock critical section would be problematic (due to embedded bpf_spin_lock in map value surfacing a deadlock opportunity). KF_OK_IN_SPIN_LOCK_CS is another option, but slightly longer than the previous proposal.

In any case, let's choose this or the former one, and not fret too much about the naming. We can also choose a better name later on.

#6 lore raw
Quoted 1 line · Kumar Kartikeya Dwivedi

On Tue Aug 4, 2026 at 12:09 PM CEST, Kaitao Cheng wrote:

[...]

Quoted 12 lines
Quoted 2 lines

Alternatively, following the naming of GFP_ATOMIC, could we call it KF_ATOMIC?

I think that is also confusing, every kfunc is allowed in atomic context in general. E.g. bpf_map_update_elem() in spin lock critical section would be problematic (due to embedded bpf_spin_lock in map value surfacing a deadlock opportunity). KF_OK_IN_SPIN_LOCK_CS is another option, but slightly longer than the previous proposal.

In any case, let's choose this or the former one, and not fret too much about the naming. We can also choose a better name later on.

KF_LOCK_SAFE? Since other kfuncs are lock-unsafe for verifier.

Thanks,
Leon

#7 lore raw
Quoted 13 lines · Leon Hwang
Quoted 1 line · Kumar Kartikeya Dwivedi

On Tue Aug 4, 2026 at 12:09 PM CEST, Kaitao Cheng wrote:

[...]

Quoted 9 lines
Quoted 2 lines

Alternatively, following the naming of GFP_ATOMIC, could we call it KF_ATOMIC?

I think that is also confusing, every kfunc is allowed in atomic context in general. E.g. bpf_map_update_elem() in spin lock critical section would be problematic (due to embedded bpf_spin_lock in map value surfacing a deadlock opportunity). KF_OK_IN_SPIN_LOCK_CS is another option, but slightly longer than the previous proposal.

Quoted 5 lines
Quoted 3 lines

In any case, let's choose this or the former one, and not fret too much about the naming. We can also choose a better name later on.

KF_LOCK_SAFE? Since other kfuncs are lock-unsafe for verifier.

That works too, probably better. Kaitao would probably prefer KF_SPIN_LOCK_SAFE, to make it more specific I guess.

Quoted 4 lines

Thanks,
Leon

#8 lore raw
In reply to Kaitao Cheng

[PATCH bpf-next] bpf: ...

Quoted 6 lines · Kaitao Cheng

From: Kaitao Cheng <[email protected]>

Introduce the KF_SPIN_LOCK kfunc metadata flag in BTF so kfuncs may be explicitly marked as safe to call while holding bpf_spin_lock.

Allow kfuncs defined in kernel modules to be marked with KF_SPIN_LOCK.

Sounds reasonable to me. I did see the requirement when implementing a custom struct_ops.

A selftest is required for this new flag.

Thanks,
Leon

Quoted 60 lines

Example: BTF_ID_FLAGS(func, $kfunc_name, KF_SPIN_LOCK)

---
  include/linux/btf.h   |  1 +
  kernel/bpf/verifier.c | 20 +++++++++++++++-----
  2 files changed, 16 insertions(+), 5 deletions(-)
include/linux/btf.h +1 -0
index c09b7994de4e..380dc10b6750 100644
@@ -79,6 +79,7 @@
  #define KF_ARENA_ARG1   (1 << 14) /* kfunc takes an arena pointer as its first argument */
  #define KF_ARENA_ARG2   (1 << 15) /* kfunc takes an arena pointer as its second argument */
  #define KF_IMPLICIT_ARGS (1 << 16) /* kfunc has implicit arguments supplied by the verifier */
+#define KF_SPIN_LOCK    (1 << 17) /* kfunc is allowed inside bpf_spin_lock-ed region */
 
  /*
   * Tag marking a kernel function as a kfunc. This is meant to minimize the
kernel/bpf/verifier.c +15 -5
index 7aa47342dc65..9f3feba3c2fe 100644
@@ -11657,11 +11657,21 @@ static bool is_bpf_stream_kfunc(u32 btf_id)
  	       btf_id == special_kfunc_list[KF_bpf_stream_print_stack];
  }
 
-static bool kfunc_spin_allowed(u32 btf_id)
+static bool kfunc_spin_allowed(struct bpf_verifier_env *env, s32 func_id, s16 offset)
  {
-	return is_bpf_graph_api_kfunc(btf_id) || is_bpf_iter_num_api_kfunc(btf_id) ||
-	       is_bpf_res_spin_lock_kfunc(btf_id) || is_bpf_arena_kfunc(btf_id) ||
-	       is_bpf_stream_kfunc(btf_id);
+	struct bpf_kfunc_meta kfunc;
+	int err;
+
+	if (is_bpf_graph_api_kfunc(func_id) || is_bpf_iter_num_api_kfunc(func_id) ||
+	    is_bpf_res_spin_lock_kfunc(func_id) || is_bpf_arena_kfunc(func_id) ||
+	    is_bpf_stream_kfunc(func_id))
+		return true;
+
+	err = fetch_kfunc_meta(env, func_id, offset, &kfunc);
+	if (err || !kfunc.flags)
+		return false;
+
+	return *kfunc.flags & KF_SPIN_LOCK;
  }
 
  static bool is_sync_callback_calling_kfunc(u32 btf_id)
@@ -17289,7 +17299,7 @@ static int do_check_insn(struct bpf_verifier_env *env, bool *do_print_state)
  				     insn->imm != BPF_FUNC_spin_unlock &&
  				     insn->imm != BPF_FUNC_kptr_xchg) ||
  				    (insn->src_reg == BPF_PSEUDO_KFUNC_CALL &&
-				     (insn->off != 0 || !kfunc_spin_allowed(insn->imm)))) {
+				     !kfunc_spin_allowed(env, insn->imm, insn->off))) {
  					verbose(env,
  						"function calls are not allowed while holding a lock\n");
  					return -EINVAL;