From: Yonghong Song <yonghong.song@linux.dev>
To: bpf@vger.kernel.org
Cc: Alexei Starovoitov <ast@kernel.org>,
Andrii Nakryiko <andrii@kernel.org>,
Daniel Borkmann <daniel@iogearbox.net>,
Eduard Zingerman <eddyz87@gmail.com>,
kernel-team@fb.com
Subject: [PATCH bpf-next v5 1/3] libbpf: Fix CO-RE relocations of unsigned 32-bit enum values
Date: Fri, 20 Nov 2026 13:50:02 -0800 [thread overview]
Message-ID: <20261120215002.868773-1-yonghong.song@linux.dev> (raw)
In-Reply-To: <20261120214957.868409-1-yonghong.song@linux.dev>
For a BPF_CORE_ENUMVAL_VALUE relocation, bpf_core_calc_enumval_relo()
reads the value of a 32-bit enumerator from btf_enum->val, which is
__s32, so the value is sign-extended to 64 bits even if the enum is
unsigned. A value in [0x80000000, 0xffffffff] of an unsigned enum
becomes 0xffffffff80000000 or above.
Clang emits such a value zero-extended in the ld_imm64 of the
relocation, so the check of the original value fails, and the whole
object is refused even if the target value is the same:
enum dentry_flags { DCACHE_PRIVATE = 0x80000000 };
out = bpf_core_enum_value(enum dentry_flags, DCACHE_PRIVATE);
libbpf: prog 'p': relo #0: unexpected insn #0 (LDIMM64) value: got
2147483648, exp 18446744071562067968 -> 18446744071562067968
libbpf: prog 'p': relo #0: failed to patch insn #0: -EINVAL
And a target value in that range is patched sign-extended, which is
wrong wherever the program uses it as a 64-bit value. The x86 vmlinux
has 29 enums with such values, e.g., dentry_flags, init_ns_ino and
e820_type.
Commit 89e7a42e3030 ("libbpf: Normalize enum values according to
signedness") fixed this for btf_dump and map fields, but not for CO-RE
relocations, whose relo_core.c is also built into the kernel. Keep the
sign extension in bpf_core_calc_enumval_relo(), and zero-extend the
32-bit values of unsigned enums, i.e., with the kflag 0, once in
bpf_core_calc_relo().
The kflag 0 of the target enum doesn't always mean unsigned, though.
Before commit 6089fb325cf7 ("bpf: Add btf enum64 support") in v6.0, the
kernel refused an enum with the kflag set, so the BTF of an older kernel
has the kflag 0 on every enum, signed or not. pahole doesn't record the
signedness before v1.24 either, and the kernel still accepts pahole
v1.22. On such a kernel, zero-extending a negative target value would
make, e.g., 0xffffffff instead of -1:
long v = bpf_core_enum_value(enum perf_event_state,
PERF_EVENT_STATE_OFF);
The local enum has the kflag 1, so the original value matches the
ld_imm64, and nothing would warn. So zero-extend the target value only
if the local enum has the kflag 0 too. A target value is then
zero-extended only if neither enum is signed.
GCC, however, sign-extends every 32-bit enum value, since its
__builtin_preserve_enum_value() returns int. For the example above:
clang: r1 = 0x80000000 ll
gcc: lddw %r1,-2147483648
An object built by GCC is accepted today, because the original value is
sign-extended too, and the change above alone would refuse it:
libbpf: prog 'p': relo #0: unexpected insn #0 (LDIMM64) value: got
18446744071562067968, exp 2147483648 -> 2147483648
The two forms differ only for an unsigned value in [0x80000000,
0xffffffff]. For such a value, accept the sign-extended form as well.
In that case, also sign-extend the target value, since GCC code uses
the ld_imm64 as the int value widened to 64 bits.
An original value below 0x80000000 is the same in both forms, so the
instruction doesn't show which compiler emitted it. The target value
then gets the extension above, which is the form clang emits, as its
builtin returns long. A target value that doesn't fit in 32 bits, e.g.,
from an enum64 in the target kernel, is patched unchanged.
In summary, a 32-bit target value is extended as follows, where kflag 1
is signed:
local enum target enum clang GCC
---------- ----------- ----- ----------
kflag 1 kflag 1 sign sign
kflag 1 kflag 0 sign sign
kflag 0 kflag 1 sign sign
kflag 0 kflag 0 zero zero, or sign (*)
(*) sign if the local value is in [0x80000000, 0xffffffff], since
GCC emits it sign-extended in the ld_imm64
Fixes: 776281652ddc ("libbpf: Permit 64bit relocation value")
Signed-off-by: Yonghong Song <yonghong.song@linux.dev>
---
tools/lib/bpf/relo_core.c | 31 +++++++++++++++++++++++++++++++
1 file changed, 31 insertions(+)
diff --git a/tools/lib/bpf/relo_core.c b/tools/lib/bpf/relo_core.c
index 2672623a4198..3f37a0879c40 100644
--- a/tools/lib/bpf/relo_core.c
+++ b/tools/lib/bpf/relo_core.c
@@ -887,6 +887,28 @@ static int bpf_core_calc_enumval_relo(const struct bpf_core_relo *relo,
return 0;
}
+/*
+ * btf_enum->val is __s32, so both values are sign-extended at this point.
+ * clang zero-extends the value of an unsigned enum.
+ * kflag == 0 is an unsigned enum or BTF without signedness (kernel before
+ * v6.0, pahole before v1.24), so new_val needs kflag == 0 on both sides.
+ */
+static void bpf_core_zext_enumval(const struct bpf_core_spec *local_spec,
+ const struct bpf_core_spec *targ_spec,
+ struct bpf_core_relo_res *res)
+{
+ const struct btf_type *local_t, *targ_t;
+
+ local_t = btf_type_by_id(local_spec->btf, local_spec->spec[0].type_id);
+ targ_t = btf_type_by_id(targ_spec->btf, targ_spec->spec[0].type_id);
+ if (BTF_INFO_KFLAG(local_t->info))
+ return;
+ if (btf_is_enum(local_t))
+ res->orig_val = (__u32)res->orig_val;
+ if (btf_is_enum(targ_t) && !BTF_INFO_KFLAG(targ_t->info))
+ res->new_val = (__u32)res->new_val;
+}
+
/* Calculate original and target relocation values, given local and target
* specs and relocation kind. These values are calculated for each candidate.
* If there are multiple candidates, resulting values should all be consistent
@@ -962,6 +984,8 @@ static int bpf_core_calc_relo(const char *prog_name,
} else if (core_relo_is_enumval_based(relo->kind)) {
err = bpf_core_calc_enumval_relo(relo, local_spec, &res->orig_val);
err = err ?: bpf_core_calc_enumval_relo(relo, targ_spec, &res->new_val);
+ if (!err && relo->kind == BPF_CORE_ENUMVAL_VALUE)
+ bpf_core_zext_enumval(local_spec, targ_spec, res);
}
done:
@@ -1144,6 +1168,13 @@ int bpf_core_patch_insn(const char *prog_name, struct bpf_insn *insn,
return bpf_core_poison_insn(prog_name, relo_idx, insn, insn_idx);
imm = (__u32)insn[0].imm | ((__u64)insn[1].imm << 32);
+ /* GCC sign-extends the value of an unsigned enum. Keep its form. */
+ if (relo->kind == BPF_CORE_ENUMVAL_VALUE && orig_val <= UINT_MAX &&
+ imm != orig_val && imm == (__u64)(__s32)orig_val) {
+ orig_val = imm;
+ if (new_val <= UINT_MAX)
+ new_val = (__s32)new_val;
+ }
if (res->validate && imm != orig_val) {
pr_warn("prog '%s': relo #%d: unexpected insn #%d (LDIMM64) value: got %llu, exp %llu -> %llu\n",
prog_name, relo_idx,
--
2.53.1-Meta
next prev parent reply other threads:[~2026-11-20 21:50 UTC|newest]
Thread overview: 5+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-20 21:49 [PATCH bpf-next v5 0/3] libbpf: Fix CO-RE relocations of unsigned 32-bit enum values Yonghong Song
2026-11-20 21:50 ` Yonghong Song [this message]
2026-11-20 21:50 ` [PATCH bpf-next v5 2/3] selftests/bpf: Test " Yonghong Song
2026-11-20 21:50 ` [PATCH bpf-next v5 3/3] selftests/bpf: Test CO-RE relocations of signed enum values without kflag Yonghong Song
2026-11-20 22:39 ` bot+bpf-ci
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=20261120215002.868773-1-yonghong.song@linux.dev \
--to=yonghong.song@linux.dev \
--cc=andrii@kernel.org \
--cc=ast@kernel.org \
--cc=bpf@vger.kernel.org \
--cc=daniel@iogearbox.net \
--cc=eddyz87@gmail.com \
--cc=kernel-team@fb.com \
/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