From: "Alexis Lothoré (eBPF Foundation)" <alexis.lothore@bootlin.com>
To: Alexei Starovoitov <ast@kernel.org>,
Daniel Borkmann <daniel@iogearbox.net>,
John Fastabend <john.fastabend@gmail.com>,
Andrii Nakryiko <andrii@kernel.org>,
Martin KaFai Lau <martin.lau@linux.dev>,
Eduard Zingerman <eddyz87@gmail.com>,
Kumar Kartikeya Dwivedi <memxor@gmail.com>,
Song Liu <song@kernel.org>,
Yonghong Song <yonghong.song@linux.dev>,
Jiri Olsa <jolsa@kernel.org>, Thomas Gleixner <tglx@kernel.org>,
Borislav Petkov <bp@alien8.de>,
Dave Hansen <dave.hansen@linux.intel.com>,
x86@kernel.org, "H. Peter Anvin" <hpa@zytor.com>,
Shuah Khan <shuah@kernel.org>, Ingo Molnar <mingo@redhat.com>,
Andrey Konovalov <andreyknvl@gmail.com>
Cc: ebpf@linuxfoundation.org,
"Bastien Curutchet" <bastien.curutchet@bootlin.com>,
"Thomas Petazzoni" <thomas.petazzoni@bootlin.com>,
bpf@vger.kernel.org, linux-kernel@vger.kernel.org,
linux-kselftest@vger.kernel.org,
"Alexis Lothoré (eBPF Foundation)" <alexis.lothore@bootlin.com>
Subject: [PATCH bpf-next v5 01/10] bpf: propagate original instruction offset when patching program
Date: Thu, 09 Jul 2026 12:01:42 +0200 [thread overview]
Message-ID: <20260709-kasan-v5-1-1c64af8e4e1e@bootlin.com> (raw)
In-Reply-To: <20260709-kasan-v5-0-1c64af8e4e1e@bootlin.com>
When the verifier patches an ebpf program with bpf_patch_insn_data, it
then calls adjust_insn_aux_data to make sure that insn_aux_data takes
into account the newly inserted patch. Some of the data offset is pretty
straightforward to deduce, it is for example the case for
indirect_target, as any patch affecting indirect calls will
systematically move the original instruction to the end of the new
patch.
In order to introduce KASAN support for eBPF JIT, we need to mark any
load/store instruction that accesses non-stack memory, but updating this
new marking after a patch is not as straightforward as for indirect
calls: the original BPF_ST/BPF_STX/BPF_LDX can be at the beginning, at
the end or somewhere in the middle of the new patch: we then need some
additional info to properly update this marking.
Add a new parameter to bpf_patch_insn_data and adjust_insn_aux_data to
convey the info about the new location in the patch of the original
instruction. This info does not always make sense depending on the
generated patch (eg, some bpf helpers being inlined by the verifier, and
so turned into multiple new instructions without any remaining BPF_CALL),
the parameter can then be set to -1. It will be used in next patches to
properly handle insn_aux_data adjustment for the new KASAN
instrumentation
Signed-off-by: Alexis Lothoré (eBPF Foundation) <alexis.lothore@bootlin.com>
---
Changes in v5:
- fix a few incorrect offset values
Changes in v4:
- define insn_off_in_patch inside convert_ctx_accesses main loop to
avoid old value leakage
Changes in v3:
- new patch
---
include/linux/filter.h | 10 +++--
kernel/bpf/core.c | 2 +-
kernel/bpf/fixups.c | 100 ++++++++++++++++++++++++++++++++-----------------
3 files changed, 74 insertions(+), 38 deletions(-)
diff --git a/include/linux/filter.h b/include/linux/filter.h
index 14acb2455746..1ebcd247ef4e 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -1210,13 +1210,17 @@ struct bpf_prog *bpf_patch_insn_single(struct bpf_prog *prog, u32 off,
#ifdef CONFIG_BPF_SYSCALL
struct bpf_prog *bpf_patch_insn_data(struct bpf_verifier_env *env, u32 off,
- const struct bpf_insn *patch, u32 len);
+ const struct bpf_insn *patch, u32 len,
+ s32 insn_off_in_patch);
struct bpf_insn_aux_data *bpf_dup_insn_aux_data(struct bpf_verifier_env *env);
void bpf_restore_insn_aux_data(struct bpf_verifier_env *env,
struct bpf_insn_aux_data *orig_insn_aux);
#else
-static inline struct bpf_prog *bpf_patch_insn_data(struct bpf_verifier_env *env, u32 off,
- const struct bpf_insn *patch, u32 len)
+static inline struct bpf_prog *bpf_patch_insn_data(struct bpf_verifier_env *env,
+ u32 off,
+ const struct bpf_insn *patch,
+ u32 len,
+ s32 insn_off_in_patch)
{
return ERR_PTR(-ENOTSUPP);
}
diff --git a/kernel/bpf/core.c b/kernel/bpf/core.c
index 47fe047ad30b..cff0035f401a 100644
--- a/kernel/bpf/core.c
+++ b/kernel/bpf/core.c
@@ -1599,7 +1599,7 @@ struct bpf_prog *bpf_jit_blind_constants(struct bpf_verifier_env *env, struct bp
continue;
if (env)
- tmp = bpf_patch_insn_data(env, i, insn_buff, rewritten);
+ tmp = bpf_patch_insn_data(env, i, insn_buff, rewritten, rewritten - 1);
else
tmp = bpf_patch_insn_single(clone, i, insn_buff, rewritten);
diff --git a/kernel/bpf/fixups.c b/kernel/bpf/fixups.c
index d3be972714b2..188ea6205d61 100644
--- a/kernel/bpf/fixups.c
+++ b/kernel/bpf/fixups.c
@@ -157,7 +157,8 @@ static int get_callee_stack_depth(struct bpf_verifier_env *env,
* [0, off) and [off, end) to new locations, so the patched range stays zero
*/
static void adjust_insn_aux_data(struct bpf_verifier_env *env,
- struct bpf_prog *new_prog, u32 off, u32 cnt)
+ struct bpf_prog *new_prog, u32 off, u32 cnt,
+ s32 insn_off_in_patch)
{
struct bpf_insn_aux_data *data = env->insn_aux_data;
struct bpf_insn *insn = new_prog->insnsi;
@@ -245,7 +246,8 @@ static void adjust_poke_descs(struct bpf_prog *prog, u32 off, u32 len)
}
struct bpf_prog *bpf_patch_insn_data(struct bpf_verifier_env *env, u32 off,
- const struct bpf_insn *patch, u32 len)
+ const struct bpf_insn *patch, u32 len,
+ s32 insn_off_in_patch)
{
struct bpf_prog *new_prog;
struct bpf_insn_aux_data *new_data = NULL;
@@ -269,7 +271,7 @@ struct bpf_prog *bpf_patch_insn_data(struct bpf_verifier_env *env, u32 off,
env->insn_aux_data[off].orig_idx);
return NULL;
}
- adjust_insn_aux_data(env, new_prog, off, len);
+ adjust_insn_aux_data(env, new_prog, off, len, insn_off_in_patch);
adjust_subprog_starts(env, off, len);
adjust_insn_arrays(env, off, len);
adjust_poke_descs(new_prog, off, len);
@@ -668,7 +670,7 @@ int bpf_opt_subreg_zext_lo32_rnd_hi32(struct bpf_verifier_env *env,
patch = zext_patch;
patch_len = 2;
apply_patch_buffer:
- new_prog = bpf_patch_insn_data(env, adj_idx, patch, patch_len);
+ new_prog = bpf_patch_insn_data(env, adj_idx, patch, patch_len, 0);
if (!new_prog)
return -ENOMEM;
env->prog = new_prog;
@@ -713,7 +715,7 @@ int bpf_convert_ctx_accesses(struct bpf_verifier_env *env)
insn_buf[cnt++] = BPF_STX_MEM(BPF_DW, BPF_REG_FP, BPF_REG_1,
-subprogs[0].stack_depth);
insn_buf[cnt++] = env->prog->insnsi[0];
- new_prog = bpf_patch_insn_data(env, 0, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, 0, insn_buf, cnt, 1);
if (!new_prog)
return -ENOMEM;
env->prog = new_prog;
@@ -736,7 +738,8 @@ int bpf_convert_ctx_accesses(struct bpf_verifier_env *env)
verifier_bug(env, "prologue is too long");
return -EFAULT;
} else if (cnt) {
- new_prog = bpf_patch_insn_data(env, 0, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, 0, insn_buf, cnt,
+ cnt - 1);
if (!new_prog)
return -ENOMEM;
@@ -768,7 +771,8 @@ int bpf_convert_ctx_accesses(struct bpf_verifier_env *env)
*patch++ = BPF_ST_NOSPEC();
*patch++ = *insn;
cnt = patch - insn_buf;
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, cnt - 1);
if (!new_prog)
return -ENOMEM;
@@ -841,7 +845,8 @@ int bpf_convert_ctx_accesses(struct bpf_verifier_env *env)
*patch++ = *insn;
*patch++ = BPF_ST_NOSPEC();
cnt = patch - insn_buf;
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, 0);
if (!new_prog)
return -ENOMEM;
@@ -971,7 +976,8 @@ int bpf_convert_ctx_accesses(struct bpf_verifier_env *env)
size * 8, 0);
patch_insn_buf:
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog =
+ bpf_patch_insn_data(env, i + delta, insn_buf, cnt, -1);
if (!new_prog)
return -ENOMEM;
@@ -1463,7 +1469,7 @@ static int add_hidden_subprog(struct bpf_verifier_env *env, struct bpf_insn *pat
* ones for the hidden subprog. Hence all of the adjustment operations
* in bpf_patch_insn_data are no-ops.
*/
- prog = bpf_patch_insn_data(env, env->prog->len - 1, patch, len);
+ prog = bpf_patch_insn_data(env, env->prog->len - 1, patch, len, 0);
if (!prog)
return -ENOMEM;
env->prog = prog;
@@ -1548,7 +1554,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
cnt = patch - insn_buf;
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, 0);
if (!new_prog)
return -ENOMEM;
@@ -1568,6 +1575,7 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
bool is_sdiv = isdiv && insn->off == 1;
bool is_smod = !isdiv && insn->off == 1;
struct bpf_insn *patch = insn_buf;
+ s32 insn_off_in_patch;
if (is_sdiv) {
/* [R,W]x sdiv 0 -> 0
@@ -1594,6 +1602,7 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
*patch++ = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
*patch++ = *insn;
cnt = patch - insn_buf;
+ insn_off_in_patch = cnt - 1;
} else if (is_smod) {
/* [R,W]x mod 0 -> [R,W]x */
/* [R,W]x mod -1 -> 0 */
@@ -1610,6 +1619,7 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
*patch++ = BPF_MOV32_IMM(insn->dst_reg, 0);
*patch++ = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
*patch++ = *insn;
+ insn_off_in_patch = patch - insn_buf - 1;
if (!is64) {
*patch++ = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
@@ -1625,12 +1635,14 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
*patch++ = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
*patch++ = *insn;
cnt = patch - insn_buf;
+ insn_off_in_patch = cnt - 1;
} else {
/* [R,W]x mod 0 -> [R,W]x */
*patch++ = BPF_RAW_INSN((is64 ? BPF_JMP : BPF_JMP32) |
BPF_JEQ | BPF_K, insn->src_reg,
0, 1 + (is64 ? 0 : 1), 0);
*patch++ = *insn;
+ insn_off_in_patch = patch - insn_buf - 1;
if (!is64) {
*patch++ = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
@@ -1639,7 +1651,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
cnt = patch - insn_buf;
}
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, insn_off_in_patch);
if (!new_prog)
return -ENOMEM;
@@ -1655,6 +1668,7 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
BPF_MODE(insn->code) == BPF_PROBE_MEMSX)) {
struct bpf_insn *patch = insn_buf;
u64 uaddress_limit = bpf_arch_uaddress_limit();
+ s32 insn_off_in_patch;
if (!uaddress_limit)
goto next_insn;
@@ -1665,11 +1679,13 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
*patch++ = BPF_ALU64_IMM(BPF_RSH, BPF_REG_AX, 32);
*patch++ = BPF_JMP_IMM(BPF_JLE, BPF_REG_AX, uaddress_limit >> 32, 2);
*patch++ = *insn;
+ insn_off_in_patch = patch - insn_buf - 1;
*patch++ = BPF_JMP_IMM(BPF_JA, 0, 0, 1);
*patch++ = BPF_MOV64_IMM(insn->dst_reg, 0);
cnt = patch - insn_buf;
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, insn_off_in_patch);
if (!new_prog)
return -ENOMEM;
@@ -1689,7 +1705,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
return -EFAULT;
}
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, 0);
if (!new_prog)
return -ENOMEM;
@@ -1742,7 +1759,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
*patch++ = BPF_ALU64_IMM(BPF_MUL, off_reg, -1);
cnt = patch - insn_buf;
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, cnt - 1);
if (!new_prog)
return -ENOMEM;
@@ -1787,7 +1805,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
insn_buf[6] = BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_AX, stack_off_cnt);
cnt = 7;
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, 3);
if (!new_prog)
return -ENOMEM;
@@ -1808,7 +1827,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
insn_buf[3] = BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_AX, stack_off);
cnt = 4;
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, 2);
if (!new_prog)
return -ENOMEM;
@@ -1829,7 +1849,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
if (cnt == 0)
goto next_insn;
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, cnt - 1);
if (!new_prog)
return -ENOMEM;
@@ -1916,7 +1937,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
map)->index_mask);
insn_buf[2] = *insn;
cnt = 3;
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, cnt - 1);
if (!new_prog)
return -ENOMEM;
@@ -1949,7 +1971,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
insn_buf[2] = *insn;
cnt = 3;
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, cnt - 1);
if (!new_prog)
return -ENOMEM;
@@ -1968,7 +1991,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
insn_buf[1] = *insn;
cnt = 2;
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, cnt - 1);
if (!new_prog)
return -ENOMEM;
@@ -2008,8 +2032,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
return -EFAULT;
}
- new_prog = bpf_patch_insn_data(env, i + delta,
- insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(
+ env, i + delta, insn_buf, cnt, -1);
if (!new_prog)
return -ENOMEM;
@@ -2092,7 +2116,7 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
cnt = 3;
new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
- cnt);
+ cnt, -1);
if (!new_prog)
return -ENOMEM;
@@ -2120,7 +2144,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
insn_buf[0] = BPF_ALU32_REG(BPF_XOR, BPF_REG_0, BPF_REG_0);
cnt = 1;
#endif
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, -1);
if (!new_prog)
return -ENOMEM;
@@ -2138,7 +2163,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
insn_buf[2] = BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0);
cnt = 3;
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, -1);
if (!new_prog)
return -ENOMEM;
@@ -2172,7 +2198,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
insn_buf[cnt++] = BPF_JMP_A(1);
insn_buf[cnt++] = BPF_MOV64_IMM(BPF_REG_0, -EINVAL);
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, -1);
if (!new_prog)
return -ENOMEM;
@@ -2204,7 +2231,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
cnt = 1;
}
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, -1);
if (!new_prog)
return -ENOMEM;
@@ -2230,7 +2258,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
cnt = 2;
}
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, -1);
if (!new_prog)
return -ENOMEM;
@@ -2246,7 +2275,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
/* Load IP address from ctx - 16 */
insn_buf[0] = BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -16);
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, 1);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ 1, -1);
if (!new_prog)
return -ENOMEM;
@@ -2301,7 +2331,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
insn_buf[10] = BPF_MOV64_IMM(BPF_REG_0, -ENOENT);
cnt = 11;
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, -1);
if (!new_prog)
return -ENOMEM;
@@ -2319,7 +2350,8 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
insn_buf[1] = BPF_ATOMIC_OP(BPF_DW, BPF_XCHG, BPF_REG_1, BPF_REG_0, 0);
cnt = 2;
- new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, i + delta, insn_buf,
+ cnt, -1);
if (!new_prog)
return -ENOMEM;
@@ -2387,7 +2419,7 @@ int bpf_do_misc_fixups(struct bpf_verifier_env *env)
/* Copy first actual insn to preserve it */
insn_buf[cnt++] = env->prog->insnsi[subprog_start];
- new_prog = bpf_patch_insn_data(env, subprog_start, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, subprog_start, insn_buf, cnt, cnt - 1);
if (!new_prog)
return -ENOMEM;
env->prog = prog = new_prog;
@@ -2486,7 +2518,7 @@ static struct bpf_prog *inline_bpf_loop(struct bpf_verifier_env *env,
insn_buf[cnt++] = BPF_LDX_MEM(BPF_DW, BPF_REG_8, BPF_REG_10, r8_offset);
*total_cnt = cnt;
- new_prog = bpf_patch_insn_data(env, position, insn_buf, cnt);
+ new_prog = bpf_patch_insn_data(env, position, insn_buf, cnt, -1);
if (!new_prog)
return new_prog;
--
2.54.0
next prev parent reply other threads:[~2026-07-09 10:03 UTC|newest]
Thread overview: 13+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-07-09 10:01 [PATCH bpf-next v5 00/10] bpf: add support for KASAN checks in JITed programs Alexis Lothoré (eBPF Foundation)
2026-07-09 10:01 ` Alexis Lothoré (eBPF Foundation) [this message]
2026-07-09 10:01 ` [PATCH bpf-next v5 02/10] bpf: mark instructions accessing program stack Alexis Lothoré (eBPF Foundation)
2026-07-09 10:01 ` [PATCH bpf-next v5 03/10] bpf: add BPF_JIT_KASAN for KASAN instrumentation of JITed programs Alexis Lothoré (eBPF Foundation)
2026-07-09 10:01 ` [PATCH bpf-next v5 04/10] bpf, x86: add helper to emit kasan checks in x86 " Alexis Lothoré (eBPF Foundation)
2026-07-09 10:01 ` [PATCH bpf-next v5 05/10] bpf, x86: refactor BPF_ST management in do_jit Alexis Lothoré (eBPF Foundation)
2026-07-09 10:01 ` [PATCH bpf-next v5 06/10] bpf, x86: emit KASAN checks into x86 JITed programs Alexis Lothoré (eBPF Foundation)
2026-07-09 10:01 ` [PATCH bpf-next v5 07/10] bpf, x86: enable KASAN for JITed programs on x86 Alexis Lothoré (eBPF Foundation)
2026-07-09 10:01 ` [PATCH bpf-next v5 08/10] selftests/bpf: add helpers for KASAN in JIT testing Alexis Lothoré (eBPF Foundation)
2026-07-09 10:01 ` [PATCH bpf-next v5 09/10] selftests/bpf: move bpf_jit_harden helper into testing_helpers Alexis Lothoré (eBPF Foundation)
2026-07-09 10:01 ` [PATCH bpf-next v5 10/10] selftests/bpf: add tests to validate KASAN on JIT programs Alexis Lothoré (eBPF Foundation)
2026-07-09 18:53 ` [PATCH bpf-next v5 00/10] bpf: add support for KASAN checks in JITed programs Borislav Petkov
2026-07-09 19:09 ` Alexis Lothoré
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20260709-kasan-v5-1-1c64af8e4e1e@bootlin.com \
--to=alexis.lothore@bootlin.com \
--cc=andreyknvl@gmail.com \
--cc=andrii@kernel.org \
--cc=ast@kernel.org \
--cc=bastien.curutchet@bootlin.com \
--cc=bp@alien8.de \
--cc=bpf@vger.kernel.org \
--cc=daniel@iogearbox.net \
--cc=dave.hansen@linux.intel.com \
--cc=ebpf@linuxfoundation.org \
--cc=eddyz87@gmail.com \
--cc=hpa@zytor.com \
--cc=john.fastabend@gmail.com \
--cc=jolsa@kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-kselftest@vger.kernel.org \
--cc=martin.lau@linux.dev \
--cc=memxor@gmail.com \
--cc=mingo@redhat.com \
--cc=shuah@kernel.org \
--cc=song@kernel.org \
--cc=tglx@kernel.org \
--cc=thomas.petazzoni@bootlin.com \
--cc=x86@kernel.org \
--cc=yonghong.song@linux.dev \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox