All of lore.kernel.org
 help / color / mirror / Atom feed
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


  reply	other threads:[~2026-11-20 21:50 UTC|newest]

Thread overview: 4+ 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

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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.