Skip to contentSkip to conversation

bpf: Introduce bpf_in_interrupt kfunc

PATCH Superseded Leon Hwang 2 participants 4 messages Aug 22, 2025 – Aug 23, 2025

Subsystems (4)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Leon Hwang

author
#0 lore raw

cover bpf: Introduce bpf_in_interrupt kfunc

Filtering pid_tgid is meaningless when the current task is preempted by an interrupt.

To address this, introduce the bpf_in_interrupt kfunc, which allows BPF programs to determine whether they are executing in interrupt context.

Internally, bpf_in_interrupt() is a thin wrapper around in_interrupt(). It is marked as fastcall function.

On x86_64, it is inlined for efficiency.

Leon Hwang (2):
bpf: Introduce bpf_in_interrupt kfunc selftests/bpf: Add case to test bpf_in_interrupt kfunc

 kernel/bpf/helpers.c                    |  9 +++++++++
 kernel/bpf/verifier.c                   | 11 +++++++++++
 tools/testing/selftests/bpf/progs/irq.c |  7 +++++++
 3 files changed, 27 insertions(+)

--
2.50.1

author
#1 lore raw

PATCH 1/2 bpf: Introduce bpf_in_interrupt kfunc

Filtering pid_tgid is meaningless when the current task is preempted by an interrupt.

To address this, introduce the bpf_in_interrupt kfunc, which allows BPF programs to determine whether they are executing in interrupt context.

This enables programs to avoid applying pid_tgid filtering when running in such contexts.

---
 kernel/bpf/helpers.c  |  9 +++++++++
 kernel/bpf/verifier.c | 11 +++++++++++
 2 files changed, 20 insertions(+)
kernel/bpf/helpers.c +9 -0
index cdffd74ddbe65..21e14697804e5 100644
@@ -3714,6 +3714,14 @@ __bpf_kfunc int bpf_strstr(const char *s1__ign, const char *s2__ign)
 	return bpf_strnstr(s1__ign, s2__ign, XATTR_SIZE_MAX);
 }
 
+/**
+ * bpf_in_interrupt - Check whether it's in interrupt context
+ */
+__bpf_kfunc int bpf_in_interrupt(void)
+{
+	return in_interrupt();
+}
+
 __bpf_kfunc_end_defs();
 
 BTF_KFUNCS_START(generic_btf_ids)
@@ -3754,6 +3762,7 @@ BTF_ID_FLAGS(func, bpf_throw)
 #ifdef CONFIG_BPF_EVENTS
 BTF_ID_FLAGS(func, bpf_send_signal_task, KF_TRUSTED_ARGS)
 #endif
+BTF_ID_FLAGS(func, bpf_in_interrupt, KF_FASTCALL)
 BTF_KFUNCS_END(generic_btf_ids)
 
 static const struct btf_kfunc_id_set generic_kfunc_set = {
kernel/bpf/verifier.c +11 -0
index 4e47992361ea1..365d42140941d 100644
@@ -12259,6 +12259,7 @@ enum special_kfunc_type {
 	KF_bpf_res_spin_lock_irqsave,
 	KF_bpf_res_spin_unlock_irqrestore,
 	KF___bpf_trap,
+	KF_bpf_in_interrupt,
 };
 
 BTF_ID_LIST(special_kfunc_list)
@@ -12327,6 +12328,7 @@ BTF_ID(func, bpf_res_spin_unlock)
 BTF_ID(func, bpf_res_spin_lock_irqsave)
 BTF_ID(func, bpf_res_spin_unlock_irqrestore)
 BTF_ID(func, __bpf_trap)
+BTF_ID(func, bpf_in_interrupt)
 
 static bool is_kfunc_ret_null(struct bpf_kfunc_call_arg_meta *meta)
 {
@@ -21973,6 +21975,15 @@ static int fixup_kfunc_call(struct bpf_verifier_env *env, struct bpf_insn *insn,
 		   desc->func_id == special_kfunc_list[KF_bpf_rdonly_cast]) {
 		insn_buf[0] = BPF_MOV64_REG(BPF_REG_0, BPF_REG_1);
 		*cnt = 1;
+	} else if (desc->func_id == special_kfunc_list[KF_bpf_in_interrupt]) {
+#ifdef CONFIG_X86_64
+		insn_buf[0] = BPF_MOV64_IMM(BPF_REG_0, (u32)(unsigned long)&__preempt_count);
+		insn_buf[1] = BPF_MOV64_PERCPU_REG(BPF_REG_0, BPF_REG_0);
+		insn_buf[2] = BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_0, 0);
+		insn_buf[3] = BPF_ALU32_IMM(BPF_AND, BPF_REG_0, NMI_MASK | HARDIRQ_MASK |
+					    (IS_ENABLED(CONFIG_PREEMPT_RT) ? 0 : SOFTIRQ_MASK));
+		*cnt = 4;
+#endif
 	}
 
 	if (env->insn_aux_data[insn_idx].arg_prog) {
Signature · 1 line
2.50.1
author
#3 lore raw

PATCH 2/2 selftests/bpf: Add case to test bpf_in_interrupt kfunc

In reply to Leon Hwang

cd tools/testing/selftests/bpf
./test_progs -t irq
#143/29 irq/in_interrupt:OK
#143 irq:OK
Summary: 1/34 PASSED, 0 SKIPPED, 0 FAILED

---
 tools/testing/selftests/bpf/progs/irq.c | 7 +++++++
 1 file changed, 7 insertions(+)
tools/testing/selftests/bpf/progs/irq.c +7 -0
index 74d912b22de90..65a796fd1d615 100644
@@ -563,4 +563,11 @@ int irq_wrong_kfunc_class_2(struct __sk_buff *ctx)
 	return 0;
 }
 
+SEC("?tc")
+__success
+int in_interrupt(struct __sk_buff *ctx)
+{
+	return bpf_in_interrupt();
+}
+
 char _license[] SEC("license") = "GPL";
Signature · 1 line
2.50.1
#2 lore raw
In reply to Leon Hwang
kernel test robot noticed the following build errors:

Hi Leon,

kernel test robot noticed the following build errors:

[auto build test ERROR on bpf-next/master]

url:    https://github.com/intel-lab-lkp/linux/commits/Leon-Hwang/bpf-Introduce-bpf_in_interrupt-kfunc/20250822-222727
base:   https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next.git master
patch link:    https://lore.kernel.org/r/20250822141722.25318-2-leon.hwang%40linux.dev
patch subject: [PATCH bpf-next 1/2] bpf: Introduce bpf_in_interrupt kfunc
config: um-allyesconfig (https://download.01.org/0day-ci/archive/20250823/[email protected]/config)
compiler: gcc-12 (Debian 12.2.0-14+deb12u1) 12.2.0
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20250823/[email protected]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All errors (new ones prefixed by >>):

In file included from include/linux/bpf_verifier.h:9,
from kernel/bpf/verifier.c:13:
kernel/bpf/verifier.c: In function 'fixup_kfunc_call':

>> kernel/bpf/verifier.c:21980:77: error: '__preempt_count' undeclared (first use in this function); did you mean 'preempt_count'?

21980 | insn_buf[0] = BPF_MOV64_IMM(BPF_REG_0, (u32)(unsigned long)&__preempt_count);
| ^~~~~~~~~~~~~~~
include/linux/filter.h:211:26: note: in definition of macro 'BPF_MOV64_IMM'
211 | .imm = IMM })
| ^~~
kernel/bpf/verifier.c:21980:77: note: each undeclared identifier is reported only once for each function it appears in
21980 | insn_buf[0] = BPF_MOV64_IMM(BPF_REG_0, (u32)(unsigned long)&__preempt_count);
| ^~~~~~~~~~~~~~~
include/linux/filter.h:211:26: note: in definition of macro 'BPF_MOV64_IMM'
211 | .imm = IMM })
| ^~~

vim +21980 kernel/bpf/verifier.c

21885
21886 static int fixup_kfunc_call(struct bpf_verifier_env *env, struct bpf_insn *insn,
21887 struct bpf_insn *insn_buf, int insn_idx, int *cnt)
21888 {
21889 const struct bpf_kfunc_desc *desc;
21890
21891 if (!insn->imm) {
21892 verbose(env, "invalid kernel function call not eliminated in verifier pass\n");
21893 return -EINVAL;
21894 }
21895
21896 *cnt = 0;
21897
21898 /* insn->imm has the btf func_id. Replace it with an offset relative to
21899 * __bpf_call_base, unless the JIT needs to call functions that are
21900 * further than 32 bits away (bpf_jit_supports_far_kfunc_call()).
21901 */
21902 desc = find_kfunc_desc(env->prog, insn->imm, insn->off);
21903 if (!desc) {
21904 verifier_bug(env, "kernel function descriptor not found for func_id %u",
21905 insn->imm);
21906 return -EFAULT;
21907 }
21908
21909 if (!bpf_jit_supports_far_kfunc_call())
21910 insn->imm = BPF_CALL_IMM(desc->addr);
21911 if (insn->off)
21912 return 0;
21913 if (desc->func_id == special_kfunc_list[KF_bpf_obj_new_impl] ||
21914 desc->func_id == special_kfunc_list[KF_bpf_percpu_obj_new_impl]) {
21915 struct btf_struct_meta *kptr_struct_meta = env->insn_aux_data[insn_idx].kptr_struct_meta;
21916 struct bpf_insn addr[2] = { BPF_LD_IMM64(BPF_REG_2, (long)kptr_struct_meta) };
21917 u64 obj_new_size = env->insn_aux_data[insn_idx].obj_new_size;
21918
21919 if (desc->func_id == special_kfunc_list[KF_bpf_percpu_obj_new_impl] && kptr_struct_meta) {
21920 verifier_bug(env, "NULL kptr_struct_meta expected at insn_idx %d",
21921 insn_idx);
21922 return -EFAULT;
21923 }
21924
21925 insn_buf[0] = BPF_MOV64_IMM(BPF_REG_1, obj_new_size);
21926 insn_buf[1] = addr[0];
21927 insn_buf[2] = addr[1];
21928 insn_buf[3] = *insn;
21929 *cnt = 4;

 21930		} else if (desc->func_id == special_kfunc_list[KF_bpf_obj_drop_impl] ||
 21931			   desc->func_id == special_kfunc_list[KF_bpf_percpu_obj_drop_impl] ||

21932 desc->func_id == special_kfunc_list[KF_bpf_refcount_acquire_impl]) {
21933 struct btf_struct_meta *kptr_struct_meta = env->insn_aux_data[insn_idx].kptr_struct_meta;
21934 struct bpf_insn addr[2] = { BPF_LD_IMM64(BPF_REG_2, (long)kptr_struct_meta) };
21935
21936 if (desc->func_id == special_kfunc_list[KF_bpf_percpu_obj_drop_impl] && kptr_struct_meta) {
21937 verifier_bug(env, "NULL kptr_struct_meta expected at insn_idx %d",
21938 insn_idx);
21939 return -EFAULT;
21940 }
21941
21942 if (desc->func_id == special_kfunc_list[KF_bpf_refcount_acquire_impl] &&
21943 !kptr_struct_meta) {
21944 verifier_bug(env, "kptr_struct_meta expected at insn_idx %d",
21945 insn_idx);
21946 return -EFAULT;
21947 }
21948
21949 insn_buf[0] = addr[0];
21950 insn_buf[1] = addr[1];
21951 insn_buf[2] = *insn;
21952 *cnt = 3;
21953 } else if (desc->func_id == special_kfunc_list[KF_bpf_list_push_back_impl] ||
21954 desc->func_id == special_kfunc_list[KF_bpf_list_push_front_impl] ||
21955 desc->func_id == special_kfunc_list[KF_bpf_rbtree_add_impl]) {
21956 struct btf_struct_meta *kptr_struct_meta = env->insn_aux_data[insn_idx].kptr_struct_meta;
21957 int struct_meta_reg = BPF_REG_3;
21958 int node_offset_reg = BPF_REG_4;
21959
21960 /* rbtree_add has extra 'less' arg, so args-to-fixup are in diff regs */
21961 if (desc->func_id == special_kfunc_list[KF_bpf_rbtree_add_impl]) {
21962 struct_meta_reg = BPF_REG_4;
21963 node_offset_reg = BPF_REG_5;
21964 }
21965
21966 if (!kptr_struct_meta) {
21967 verifier_bug(env, "kptr_struct_meta expected at insn_idx %d",
21968 insn_idx);
21969 return -EFAULT;
21970 }
21971
21972 __fixup_collection_insert_kfunc(&env->insn_aux_data[insn_idx], struct_meta_reg,
21973 node_offset_reg, insn, insn_buf, cnt);
21974 } else if (desc->func_id == special_kfunc_list[KF_bpf_cast_to_kern_ctx] ||
21975 desc->func_id == special_kfunc_list[KF_bpf_rdonly_cast]) {
21976 insn_buf[0] = BPF_MOV64_REG(BPF_REG_0, BPF_REG_1);
21977 *cnt = 1;
21978 } else if (desc->func_id == special_kfunc_list[KF_bpf_in_interrupt]) {
21979 #ifdef CONFIG_X86_64
21980 insn_buf[0] = BPF_MOV64_IMM(BPF_REG_0, (u32)(unsigned long)&__preempt_count);
21981 insn_buf[1] = BPF_MOV64_PERCPU_REG(BPF_REG_0, BPF_REG_0);
21982 insn_buf[2] = BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_0, 0);
21983 insn_buf[3] = BPF_ALU32_IMM(BPF_AND, BPF_REG_0, NMI_MASK | HARDIRQ_MASK |
21984 (IS_ENABLED(CONFIG_PREEMPT_RT) ? 0 : SOFTIRQ_MASK));
21985 *cnt = 4;
21986 #endif
21987 }
21988
21989 if (env->insn_aux_data[insn_idx].arg_prog) {
21990 u32 regno = env->insn_aux_data[insn_idx].arg_prog;
21991 struct bpf_insn ld_addrs[2] = { BPF_LD_IMM64(regno, (long)env->prog->aux) };
21992 int idx = *cnt;
21993
21994 insn_buf[idx++] = ld_addrs[0];
21995 insn_buf[idx++] = ld_addrs[1];
21996 insn_buf[idx++] = *insn;
21997 *cnt = idx;
21998 }
21999 return 0;
22000 }
22001

Signature · 2 lines
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki