From: George Guo <[email protected]>
Some toolchains reference an object through a local assembler label (.L*)
rather than a section symbol plus offset. The assembler keeps the label
because a "section + constant offset" reference would go stale under
linker relaxation, while a symbol reference can be recomputed afterwards.
Such labels are assembler-local, absent from kallsyms, and are never
cloned into the livepatch object.
Two toolchains hit this:
- GCC/GAS on LoongArch references special section entries (__ex_table,
__bug_table, __jump_table, .altinstructions) through local text
labels instead of a section symbol.
- Clang emits a switch jump table through a local label (.LJTI*) in a
SHF_MERGE|SHF_STRINGS .rodata section, where the table shares the
section with the livepatch's klp_func name strings.
convert_reloc_secsym_to_sym() only handled the section symbol form and
returned early for a label reference, so the label was never converted
and the reference resolved incorrectly, with no error at build or load
time:
- GCC: should_keep_special_sym() cannot correlate the entry with an
included function and silently drops it, so the livepatch module is
missing the patched function's __ex_table / __bug_table /
__jump_table entries.
- Clang: the jump table is not cloned, and its base label resolves into
the name strings that occupy the same offset; the switch's indirect
jump then lands on a wild address and the patched function oopses at
runtime.
Redirect a local label reference off the label, mirroring the section
symbol case:
- In a text section, to the containing function symbol. A label with
no containing function symbol (e.g. hand-written asm in a plain .text
section) can't be correlated; skip it rather than failing, since such
entries belong to unchanged code and are dropped anyway.
- In a non-text section (e.g. the .rodata jump table), to the section
symbol plus the full offset.
Reported-by: Joe Lawrence <[email protected]>
Suggested-by: Joe Lawrence <[email protected]>
Co-developed-by: Kexin Liu <[email protected]>
Signed-off-by: Kexin Liu <[email protected]>
Signed-off-by: George Guo <[email protected]>
---
tools/objtool/klp-diff.c | 49 +++++++++++++++++++++++++++++++++++++++-
1 file changed, 48 insertions(+), 1 deletion(-)
diff --git a/tools/objtool/klp-diff.c b/tools/objtool/klp-diff.c
index b9624bd9439b..3e573b73fe6b 100644
--- a/tools/objtool/klp-diff.c
+++ b/tools/objtool/klp-diff.c
@@ -1423,8 +1423,55 @@ static int convert_reloc_secsym_to_sym(struct elf *elf,
struct reloc *reloc)
if (!strcmp(reloc->sec->name, ".rela__patchable_function_entries"))
return convert_pfe_reloc(elf, reloc);
- if (!is_sec_sym(sym))
+ if (!is_sec_sym(sym)) {
+ /*
+ * Most toolchains reference special-section entries via the
+ * section symbol plus an offset. GCC/GAS on LoongArch instead
+ * references a local text label (.L*): LoongArch linker
+ * relaxation is the reason GAS keeps the label rather than
+ * reducing it to a section symbol reference. Such a label is
+ * never cloned into the livepatch object, so the entry would be
+ * silently dropped. Redirect the relocation to the containing
+ * function, mirroring the section-symbol case below.
+ */
+ if (is_local_label(sym)) {
+ unsigned long offset = sym->offset +
reloc_addend(reloc);
+
+ if (is_text_sec(sec)) {
+ sym = find_symbol_containing_inclusive(sec,
offset);
+ if (!sym) {
+ /*
+ * A local label with no containing
function
+ * symbol (e.g. hand-written asm in a
plain .text
+ * section). It can't be correlated to
a function,
+ * so skip it rather than failing the
build; such
+ * entries belong to unchanged code and
are dropped
+ * anyway.
+ */
+ return 1;
+ }
+
+ reloc->sym = sym;
+ set_reloc_sym(elf, reloc, sym->idx);
+ set_reloc_addend(elf, reloc, offset -
sym->offset);
+ } else {
+ /*
+ * A local label in a non-text section, e.g.
Clang's
+ * .LJTI* switch jump table in .rodata. It
isn't
+ * cloned into the livepatch either, so
redirect the
+ * reloc to the section symbol plus the full
offset,
+ * mirroring the section-symbol case below.
+ */
+ if (!sec->sym &&
!elf_create_section_symbol(elf, sec))
+ return -1;
+ reloc->sym = sec->sym;
+ set_reloc_sym(elf, reloc, sec->sym->idx);
+ set_reloc_addend(elf, reloc, offset);
+ }
+ }
+
return 0;
+ }
sym = find_symbol_containing_inclusive(sec,
arch_adjusted_addend(reloc));
if (!sym) {
--
2.53.0
