* [PATCH v2 1/6] objtool/powerpc: Add build-time fixup of alternate feature branch targets
2026-09-29 5:51 [PATCH v2 0/6] objtool: Fixup alternate feature relative addresses Shivang Upadhyay
@ 2026-09-29 5:51 ` Shivang Upadhyay
2026-09-29 5:51 ` [PATCH v2 2/6] objtool: Set ELF_F_LAYOUT flag to preserve vmlinux segment layout Shivang Upadhyay
` (4 subsequent siblings)
5 siblings, 0 replies; 14+ messages in thread
From: Shivang Upadhyay @ 2026-09-29 5:51 UTC (permalink / raw)
To: linux-kbuild, linux-kernel, linuxppc-dev
Cc: sv, alexandre.chartre, alexghiti, aliceryhl, ardb, bp, chleroy,
elver, ihor.solodrai, jpoimboe, kees, legion, lossin, maddy,
masahiroy, mpe, nathan, npiggin, nsc, ojeda, peterz, pmladek,
rostedt, tamird, thomas.weissschuh, thuth, yuxuan.zuo,
sourabhjain, Shivang Upadhyay
From: Sathvika Vasireddy <sv@linux.ibm.com>
PowerPC __ftr_alt* sections must currently be placed near .text because
they lack the executable attribute, preventing the linker from inserting
stubs. Branches in the alternate code must reach their targets directly.
This can cause build failures as the kernel grows.
Fix this by processing alternate feature relocations at build time with
objtool. Link with --emit-relocs to preserve relocation information,
mark __ftr_alt* sections executable ("ax") so the linker can insert
stubs, then use objtool --ftr-fixup to recompute branch offsets based
on their runtime locations.
objtool already has ELF parsing and instruction patching infrastructure,
so this avoids introducing a separate tool as was originally proposed
[1].
[1]
https://lore.kernel.org/linuxppc-dev/20170521010130.13552-1-npiggin@gmail.com/
Co-developed-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Sathvika Vasireddy <sv@linux.ibm.com>
Signed-off-by: Shivang Upadhyay <shivangu@linux.ibm.com>
---
tools/objtool/arch/powerpc/decode.c | 11 +
tools/objtool/arch/powerpc/special.c | 451 ++++++++++++++++++++++++
tools/objtool/builtin-check.c | 2 +
tools/objtool/check.c | 25 ++
tools/objtool/include/objtool/builtin.h | 1 +
tools/objtool/include/objtool/special.h | 56 +++
tools/objtool/special.c | 29 ++
7 files changed, 575 insertions(+)
diff --git a/tools/objtool/arch/powerpc/decode.c b/tools/objtool/arch/powerpc/decode.c
index e534ac1123b3..5fdd142f0a19 100644
--- a/tools/objtool/arch/powerpc/decode.c
+++ b/tools/objtool/arch/powerpc/decode.c
@@ -66,6 +66,17 @@ int arch_decode_instruction(struct objtool_file *file, const struct section *sec
imm = 0;
switch (opcode) {
+ case 16: /* bc[l][a] : Branch Conditional */
+ if (ins & 1)
+ typ = INSN_OTHER;
+ else
+ typ = INSN_JUMP_CONDITIONAL;
+ imm = ins & 0xfffc;
+ if (imm & 0x8000)
+ imm -= 0x10000;
+ imm |= ins & 2; /* AA flag */
+ break;
+
case 18: /* b[l][a] */
if (ins == 0x48000005) /* bl .+4 */
typ = INSN_OTHER;
diff --git a/tools/objtool/arch/powerpc/special.c b/tools/objtool/arch/powerpc/special.c
index 8f9bf61ca089..deb248c63bca 100644
--- a/tools/objtool/arch/powerpc/special.c
+++ b/tools/objtool/arch/powerpc/special.c
@@ -3,7 +3,17 @@
#include <stdlib.h>
#include <objtool/special.h>
#include <objtool/builtin.h>
+#include <objtool/warn.h>
+#include <asm/byteorder.h>
+#include <errno.h>
+struct section *ftr_alt;
+
+struct fixup_entry *fes;
+unsigned int nr_fes;
+
+uint64_t fe_alt_start = -1;
+uint64_t fe_alt_end;
bool arch_support_alt_relocation(struct special_alt *special_alt,
struct instruction *insn,
@@ -23,3 +33,444 @@ const char *arch_cpu_feature_name(int feature_number)
{
return NULL;
}
+
+
+int process_alt_data(struct objtool_file *file)
+{
+ struct section *section;
+
+ section = find_section_by_name(file->elf, ".__ftr_alternates.text");
+ ftr_alt = section;
+
+ if (!ftr_alt) {
+ if (opts.link)
+ WARN(".__ftr_alternates.text section not found in vmlinux\n");
+ return opts.link ? -1 : 0;
+ }
+
+ fe_alt_start = ftr_alt->sh.sh_addr;
+ fe_alt_end = ftr_alt->sh.sh_addr + ftr_alt->sh.sh_size;
+
+ return 0;
+
+}
+
+static int is_le(struct objtool_file *file)
+{
+ return file->elf->ehdr.e_ident[EI_DATA] == ELFDATA2LSB;
+}
+
+static int is_64bit(struct objtool_file *file)
+{
+ return file->elf->ehdr.e_ident[EI_CLASS] == ELFCLASS64;
+}
+
+static uint32_t f32_to_cpu(struct objtool_file *file, uint32_t val)
+{
+ if (is_le(file))
+ return __le32_to_cpu(val);
+ else
+ return __be32_to_cpu(val);
+}
+
+static uint64_t f64_to_cpu(struct objtool_file *file, uint64_t val)
+{
+ if (is_le(file))
+ return __le64_to_cpu(val);
+ else
+ return __be64_to_cpu(val);
+}
+
+static uint32_t cpu_to_f32(struct objtool_file *file, uint32_t val)
+{
+ if (is_le(file))
+ return __cpu_to_le32(val);
+ else
+ return __cpu_to_be32(val);
+}
+
+int process_fixup_entries(struct objtool_file *file)
+{
+ struct section *sec;
+ int i;
+
+ for_each_sec(file->elf, sec) {
+ Elf_Data *data;
+ unsigned int nr;
+
+ if (strstr(sec->name, "_ftr_fixup") == NULL)
+ continue;
+
+ if (strstr(sec->name, ".rela") != NULL)
+ continue;
+
+ data = sec->data;
+ if (!data || data->d_size == 0)
+ continue;
+
+ if (is_64bit(file))
+ nr = data->d_size / sizeof(struct fixup_entry_64);
+ else
+ nr = data->d_size / sizeof(struct fixup_entry_32);
+
+ for (i = 0; i < nr; i++) {
+ unsigned long idx;
+ unsigned long long off;
+ struct fixup_entry *dst;
+
+ if (is_64bit(file)) {
+ struct fixup_entry_64 *src;
+
+ idx = i * sizeof(struct fixup_entry_64);
+ off = sec->sh.sh_addr + data->d_off + idx;
+ src = data->d_buf + idx;
+
+ if (src->alt_start_off == src->alt_end_off)
+ continue;
+
+ struct fixup_entry *tmp = realloc(fes, (nr_fes + 1)
+ * sizeof(struct fixup_entry));
+
+ if (!tmp) {
+ free(fes);
+ fes = NULL;
+ return -1;
+ }
+ fes = tmp;
+ dst = &fes[nr_fes++];
+
+ dst->mask = f64_to_cpu(file, src->mask);
+ dst->value = f64_to_cpu(file, src->value);
+ dst->start_off = f64_to_cpu(file, src->start_off) + off;
+ dst->end_off = f64_to_cpu(file, src->end_off) + off;
+ dst->alt_start_off = f64_to_cpu(file, src->alt_start_off) + off;
+ dst->alt_end_off = f64_to_cpu(file, src->alt_end_off) + off;
+ } else {
+ struct fixup_entry_32 *src;
+
+ idx = i * sizeof(struct fixup_entry_32);
+ off = sec->sh.sh_addr + data->d_off + idx;
+ src = data->d_buf + idx;
+
+ if (src->alt_start_off == src->alt_end_off)
+ continue;
+
+ struct fixup_entry *tmp = realloc(fes, (nr_fes + 1)
+ * sizeof(struct fixup_entry));
+
+ if (!tmp) {
+ free(fes);
+ fes = NULL;
+ return -1;
+ }
+ fes = tmp;
+ dst = &fes[nr_fes++];
+
+ dst->mask = f32_to_cpu(file, src->mask);
+ dst->value = f32_to_cpu(file, src->value);
+ dst->start_off = (int32_t)f32_to_cpu(file, src->start_off) + off;
+ dst->end_off = (int32_t)f32_to_cpu(file, src->end_off) + off;
+ dst->alt_start_off = (int32_t)f32_to_cpu(file,
+ src->alt_start_off) + off;
+ dst->alt_end_off = (int32_t)f32_to_cpu(file,
+ src->alt_end_off) + off;
+ }
+ }
+ }
+ return 0;
+}
+
+struct fixup_entry *find_fe_altaddr(uint64_t addr)
+{
+ unsigned int i;
+
+ if (addr < fe_alt_start)
+ return NULL;
+ if (addr >= fe_alt_end)
+ return NULL;
+
+ for (i = 0; i < nr_fes; i++) {
+ if (addr >= fes[i].alt_start_off && addr < fes[i].alt_end_off)
+ return &fes[i];
+ }
+ return NULL;
+}
+
+int set_uncond_branch_target(uint32_t *insn,
+ const uint64_t addr, uint64_t target)
+{
+ uint32_t i = *insn;
+ int64_t offset;
+
+ offset = target;
+ if (!(i & BRANCH_ABSOLUTE))
+ offset = offset - addr;
+
+ /* Check we can represent the target in the instruction format */
+ if (offset < -0x2000000 || offset > 0x1fffffc || offset & 0x3)
+ return -EOVERFLOW;
+
+ /* Mask out the flags and target, so they don't step on each other. */
+ *insn = 0x48000000 | (i & 0x3) | (offset & 0x03FFFFFC);
+
+ return 0;
+}
+
+int set_cond_branch_target(uint32_t *insn,
+ const uint64_t addr, uint64_t target)
+{
+ uint32_t i = *insn;
+ int64_t offset;
+
+ offset = target;
+
+ if (!(i & BRANCH_ABSOLUTE))
+ offset = offset - addr;
+
+ /* Check we can represent the target in the instruction format */
+ if (offset < -0x8000 || offset > 0x7FFF || offset & 0x3)
+ return -EOVERFLOW;
+
+ /* Mask out the flags and target, so they don't step on each other. */
+ *insn = 0x40000000 | (i & 0x3FF0003) | (offset & 0xFFFC);
+
+ return 0;
+}
+
+void check_and_flatten_fixup_entries(void)
+{
+ static struct fixup_entry *fe;
+ unsigned int i;
+
+ for (i = 0; i < nr_fes; i++) {
+ struct fixup_entry *parent;
+ uint64_t nested_off;
+ uint64_t size;
+
+ fe = &fes[i];
+
+ parent = find_fe_altaddr(fe->start_off);
+ if (!parent)
+ continue;
+
+ size = fe->end_off - fe->start_off;
+ nested_off = fe->start_off - parent->alt_start_off;
+
+ fe->start_off = parent->start_off + nested_off;
+ fe->end_off = fe->start_off + size;
+ }
+}
+
+
+static struct symbol *find_symbol_at_address_within_section(struct section *sec,
+ unsigned long address)
+{
+ struct symbol *sym;
+
+ sec_for_each_sym(sec, sym) {
+ if (sym->sym.st_value <= address && address < sym->sym.st_value + sym->len)
+ return sym;
+ }
+
+ return NULL;
+}
+
+static int is_local_symbol(uint8_t st_other)
+{
+ /* STO_PPC64_LOCAL_MASK: bits [7:5] encode the local entry point offset */
+ return (st_other & (7 << 5)) == 0;
+}
+
+static struct symbol *find_symbol_at_address(struct objtool_file *file,
+ unsigned long address)
+{
+ struct section *sec;
+ struct symbol *sym;
+
+ list_for_each_entry(sec, &file->elf->sections, list) {
+ sym = find_symbol_at_address_within_section(sec, address);
+ if (sym)
+ return sym;
+ }
+ return NULL;
+}
+
+int process_alt_relocations(struct objtool_file *file)
+{
+ struct section *section;
+ size_t n = 0;
+ struct reloc *relocation;
+ struct symbol *sym;
+ struct fixup_entry *fe;
+ uint64_t addr;
+ uint64_t scn_delta;
+ uint64_t dst_addr;
+ const char *insn_ptr;
+ unsigned long target;
+ struct symbol *symbol;
+ int is_local;
+ int j;
+ uint32_t new_insn;
+ uint32_t file_insn;
+ struct instruction decoded_insn = {0};
+ uint32_t *insn_ptr_raw;
+ uint32_t insn;
+
+ section = find_section_by_name(file->elf, ".rela.__ftr_alternates.text");
+ if (!section) {
+ printf(".rela.__ftr_alternates.text section not found.\n");
+ return 0;
+ }
+
+ for (j = 0; j < sec_num_entries(section); j++) {
+
+ relocation = §ion->relocs[j];
+ sym = relocation->sym;
+
+ addr = reloc_offset(relocation);
+ target = sym->sym.st_value + reloc_addend(relocation);
+ symbol = find_symbol_at_address(file, target);
+
+ if (symbol) {
+ is_local = is_local_symbol(symbol->sym.st_other);
+ if (!is_local)
+ target = target + 0x8;
+ }
+
+ n++;
+ fe = find_fe_altaddr(addr);
+ if (!fe)
+ continue;
+
+ if (target >= fe->alt_start_off && target < fe->alt_end_off)
+ continue;
+
+ if (target >= ftr_alt->sh.sh_addr &&
+ target < ftr_alt->sh.sh_addr + ftr_alt->sh.sh_size)
+ return -1;
+
+ scn_delta = addr - ftr_alt->sh.sh_addr;
+ dst_addr = addr - fe->alt_start_off + fe->start_off;
+
+ if (!ftr_alt->data || !ftr_alt->data->d_buf)
+ continue;
+
+ if (arch_decode_instruction(file, ftr_alt, scn_delta, 4, &decoded_insn) < 0)
+ continue;
+
+ insn_ptr_raw = (uint32_t *)(ftr_alt->data->d_buf + scn_delta);
+
+ insn = f32_to_cpu(file, *insn_ptr_raw);
+ new_insn = insn;
+
+ switch (decoded_insn.type) {
+ case INSN_JUMP_CONDITIONAL:
+ if (set_cond_branch_target(&new_insn, dst_addr, target) != 0)
+ continue;
+ break;
+
+ case INSN_JUMP_UNCONDITIONAL:
+ if (set_uncond_branch_target(&new_insn, dst_addr, target) != 0)
+ continue;
+ break;
+
+ case INSN_CALL:
+ if (set_uncond_branch_target(&new_insn, dst_addr, target) != 0)
+ continue;
+ break;
+ default:
+ continue;
+ }
+
+ if (new_insn == insn)
+ continue;
+
+ file_insn = cpu_to_f32(file, new_insn);
+ insn_ptr = (const char *)&file_insn;
+ elf_write_insn(file->elf, ftr_alt, scn_delta, sizeof(file_insn), insn_ptr);
+ }
+ return 0;
+}
+
+int process_exception_entries(struct objtool_file *file)
+{
+ struct section *section;
+ Elf_Data *data;
+ unsigned int nr, i;
+
+ section = find_section_by_name(file->elf, "__ex_table");
+ if (!section) {
+ printf("__ex_table section not found\n");
+ return 0;
+ }
+
+ data = section->data;
+ if (!data || data->d_size == 0)
+ return 0;
+
+ nr = data->d_size / sizeof(struct exception_entry);
+
+ for (i = 0; i < nr; i++) {
+ struct exception_entry *ex;
+ unsigned long idx;
+ uint64_t exaddr;
+ unsigned long long off;
+
+ idx = i * sizeof(struct exception_entry);
+ off = section->sh.sh_addr + data->d_off + idx;
+ ex = data->d_buf + idx;
+
+ exaddr = off + (int32_t)f32_to_cpu(file, ex->insn);
+
+ if (exaddr < fe_alt_start)
+ continue;
+ if (exaddr >= fe_alt_end)
+ continue;
+
+ return -1;
+ }
+ return 0;
+}
+
+int process_bug_entries(struct objtool_file *file)
+{
+ struct section *section;
+ Elf_Data *data;
+ unsigned int nr, i;
+
+ section = find_section_by_name(file->elf, "__bug_table");
+ if (!section) {
+ printf("__bug_table section not found\n");
+ return 0;
+ }
+
+ data = section->data;
+ if (!data || data->d_size == 0)
+ return 0;
+
+ if (data->d_size % sizeof(struct bug_entry) != 0)
+ return -1;
+
+ nr = data->d_size / sizeof(struct bug_entry);
+ for (i = 0; i < nr; i++) {
+ struct bug_entry *bug;
+ unsigned long idx;
+ uint64_t entry_addr;
+ uint64_t bugaddr;
+ int32_t bug_disp;
+
+ idx = i * sizeof(struct bug_entry);
+ entry_addr = section->sh.sh_addr + data->d_off + idx;
+ bug = (struct bug_entry *)(data->d_buf + idx);
+ bug_disp = f32_to_cpu(file, bug->bug_addr_disp);
+ bugaddr = entry_addr + bug_disp;
+
+ if (bugaddr < fe_alt_start)
+ continue;
+ if (bugaddr >= fe_alt_end)
+ continue;
+
+ return -1;
+ }
+ return 0;
+}
diff --git a/tools/objtool/builtin-check.c b/tools/objtool/builtin-check.c
index 75b11dc85010..ed7fdd82d997 100644
--- a/tools/objtool/builtin-check.c
+++ b/tools/objtool/builtin-check.c
@@ -77,6 +77,7 @@ static const struct option check_options[] = {
OPT_CALLBACK_OPTARG('h', "hacks", NULL, NULL, "jump_label,noinstr,skylake", "patch toolchain bugs/limitations", parse_hacks),
OPT_BOOLEAN('i', "ibt", &opts.ibt, "validate and annotate IBT"),
OPT_BOOLEAN(0, "klp-symids", &opts.klp_symids, "generate .klp.symids for duplicate symbol disambiguation"),
+ OPT_BOOLEAN('f', "ftr-fixup", &opts.ftr_fixup, "feature fixup"),
OPT_BOOLEAN('m', "mcount", &opts.mcount, "annotate mcount/fentry calls for ftrace"),
OPT_BOOLEAN(0, "noabs", &opts.noabs, "reject absolute references in allocatable sections"),
OPT_BOOLEAN('n', "noinstr", &opts.noinstr, "validate noinstr rules"),
@@ -183,6 +184,7 @@ static bool opts_valid(void)
if (opts.disas ||
opts.hack_jump_label ||
opts.hack_noinstr ||
+ opts.ftr_fixup ||
opts.ibt ||
opts.klp_symids ||
opts.mcount ||
diff --git a/tools/objtool/check.c b/tools/objtool/check.c
index 464f6c9d9ff0..2e875ac9175e 100644
--- a/tools/objtool/check.c
+++ b/tools/objtool/check.c
@@ -4840,6 +4840,31 @@ int check(struct objtool_file *file)
if (!nr_insns)
goto out;
+ if (opts.ftr_fixup) {
+ ret = process_alt_data(file);
+ if (ret < 0)
+ return ret;
+
+ ret = process_fixup_entries(file);
+ if (ret < 0)
+ return ret;
+
+ check_and_flatten_fixup_entries();
+
+ ret = process_exception_entries(file);
+ if (ret < 0)
+ return ret;
+
+ ret = process_bug_entries(file);
+ if (ret < 0)
+ return ret;
+
+ ret = process_alt_relocations(file);
+ if (ret < 0)
+ return ret;
+ }
+
+
if (opts.retpoline)
warnings += validate_retpoline(file);
diff --git a/tools/objtool/include/objtool/builtin.h b/tools/objtool/include/objtool/builtin.h
index 349690bb1c50..159255cecc27 100644
--- a/tools/objtool/include/objtool/builtin.h
+++ b/tools/objtool/include/objtool/builtin.h
@@ -13,6 +13,7 @@ struct opts {
const char *disas;
bool dump_orc;
bool hack_jump_label;
+ bool ftr_fixup;
bool hack_noinstr;
bool hack_skylake;
bool ibt;
diff --git a/tools/objtool/include/objtool/special.h b/tools/objtool/include/objtool/special.h
index 620dbf6cb0e5..eccf71e09fc3 100644
--- a/tools/objtool/include/objtool/special.h
+++ b/tools/objtool/include/objtool/special.h
@@ -12,6 +12,41 @@
#define C_JUMP_TABLE_SECTION ".data.rel.ro.c_jump_table"
+#define BRANCH_SET_LINK 0x1
+#define BRANCH_ABSOLUTE 0x2
+
+struct bug_entry {
+ int32_t bug_addr_disp;
+ int32_t file_disp;
+ uint16_t line;
+ uint16_t flags;
+};
+
+struct exception_entry {
+ int32_t insn;
+ int32_t fixup;
+};
+
+struct fixup_entry_64 {
+ uint64_t mask;
+ uint64_t value;
+ uint64_t start_off;
+ uint64_t end_off;
+ uint64_t alt_start_off;
+ uint64_t alt_end_off;
+};
+
+#define fixup_entry fixup_entry_64
+
+struct fixup_entry_32 {
+ uint32_t mask;
+ uint32_t value;
+ uint32_t start_off;
+ uint32_t end_off;
+ uint32_t alt_start_off;
+ uint32_t alt_end_off;
+};
+
struct special_alt {
struct list_head list;
@@ -28,6 +63,8 @@ struct special_alt {
unsigned int orig_len, new_len, feature; /* group only */
};
+int process_alt_data(struct objtool_file *file);
+
int special_get_alts(struct elf *elf, struct list_head *alts);
void arch_handle_alternative(struct special_alt *alt);
@@ -47,4 +84,23 @@ struct reloc *arch_find_switch_table(struct objtool_file *file,
unsigned long *table_size);
const char *arch_cpu_feature_name(int feature_number);
+int process_fixup_entries(struct objtool_file *file);
+
+void check_and_flatten_fixup_entries(void);
+
+int process_exception_entries(struct objtool_file *file);
+
+int process_bug_entries(struct objtool_file *file);
+
+int process_alt_relocations(struct objtool_file *file);
+
+struct fixup_entry *find_fe_altaddr(uint64_t addr);
+
+int set_uncond_branch_target(uint32_t *insn,
+ const uint64_t addr, uint64_t target);
+
+int set_cond_branch_target(uint32_t *insn,
+ const uint64_t addr, uint64_t target);
+
+
#endif /* _SPECIAL_H */
diff --git a/tools/objtool/special.c b/tools/objtool/special.c
index 2a533afbc69a..43b60bf789dd 100644
--- a/tools/objtool/special.c
+++ b/tools/objtool/special.c
@@ -167,3 +167,32 @@ int special_get_alts(struct elf *elf, struct list_head *alts)
return 0;
}
+
+int __weak process_alt_data(struct objtool_file *file)
+{
+ return 0;
+}
+
+int __weak process_fixup_entries(struct objtool_file *file)
+{
+ return 0;
+}
+
+void __weak check_and_flatten_fixup_entries(void)
+{
+}
+
+int __weak process_exception_entries(struct objtool_file *file)
+{
+ return 0;
+}
+
+int __weak process_bug_entries(struct objtool_file *file)
+{
+ return 0;
+}
+
+int __weak process_alt_relocations(struct objtool_file *file)
+{
+ return 0;
+}
--
2.54.0
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH v2 2/6] objtool: Set ELF_F_LAYOUT flag to preserve vmlinux segment layout
2026-09-29 5:51 [PATCH v2 0/6] objtool: Fixup alternate feature relative addresses Shivang Upadhyay
2026-09-29 5:51 ` [PATCH v2 1/6] objtool/powerpc: Add build-time fixup of alternate feature branch targets Shivang Upadhyay
@ 2026-09-29 5:51 ` Shivang Upadhyay
2026-09-30 9:48 ` Peter Zijlstra
2026-09-29 5:51 ` [PATCH v2 3/6] objtool: Fix "can't find starting instruction" warnings on vmlinux Shivang Upadhyay
` (3 subsequent siblings)
5 siblings, 1 reply; 14+ messages in thread
From: Shivang Upadhyay @ 2026-09-29 5:51 UTC (permalink / raw)
To: linux-kbuild, linux-kernel, linuxppc-dev
Cc: sv, alexandre.chartre, alexghiti, aliceryhl, ardb, bp, chleroy,
elver, ihor.solodrai, jpoimboe, kees, legion, lossin, maddy,
masahiroy, mpe, nathan, npiggin, nsc, ojeda, peterz, pmladek,
rostedt, tamird, thomas.weissschuh, thuth, yuxuan.zuo,
sourabhjain, Shivang Upadhyay
From: Sathvika Vasireddy <sv@linux.ibm.com>
When objtool writes changes back to vmlinux with --ftr-fixup --link,
libelf recalculates the file layout and inserts padding between
sections. This corrupts the ELF segment structure, causing kexec to
fail with:
ELF Note corrupted !
Cannot determine the file type of vmlinux
This happens because libelf's default behavior assumes it can freely
rearrange section offsets when writing, which breaks the carefully
constructed vmlinux layout produced by the linker.
Set ELF_F_LAYOUT after elf_begin() to instruct libelf that the
application is responsible for the file layout. This prevents libelf
from inserting padding or repositioning sections while still allowing
data modifications to be written back.
Signed-off-by: Sathvika Vasireddy <sv@linux.ibm.com>
Signed-off-by: Shivang Upadhyay <shivangu@linux.ibm.com>
---
tools/objtool/elf.c | 3 +++
1 file changed, 3 insertions(+)
diff --git a/tools/objtool/elf.c b/tools/objtool/elf.c
index a791f4ea6ec1..55c20a993f5d 100644
--- a/tools/objtool/elf.c
+++ b/tools/objtool/elf.c
@@ -1239,6 +1239,9 @@ struct elf *elf_open_read(const char *name, int flags)
goto err;
}
+ if (opts.ftr_fixup)
+ elf_flagelf(elf->elf, ELF_C_SET, ELF_F_LAYOUT);
+
if (!gelf_getehdr(elf->elf, &elf->ehdr)) {
ERROR_ELF("gelf_getehdr");
goto err;
--
2.54.0
^ permalink raw reply related [flat|nested] 14+ messages in thread* Re: [PATCH v2 2/6] objtool: Set ELF_F_LAYOUT flag to preserve vmlinux segment layout
2026-09-29 5:51 ` [PATCH v2 2/6] objtool: Set ELF_F_LAYOUT flag to preserve vmlinux segment layout Shivang Upadhyay
@ 2026-09-30 9:48 ` Peter Zijlstra
0 siblings, 0 replies; 14+ messages in thread
From: Peter Zijlstra @ 2026-09-30 9:48 UTC (permalink / raw)
To: Shivang Upadhyay
Cc: linux-kbuild, linux-kernel, linuxppc-dev, sv, alexandre.chartre,
alexghiti, aliceryhl, ardb, bp, chleroy, elver, ihor.solodrai,
jpoimboe, kees, legion, lossin, maddy, masahiroy, mpe, nathan,
npiggin, nsc, ojeda, pmladek, rostedt, tamird, thomas.weissschuh,
thuth, yuxuan.zuo, sourabhjain
On Tue, Sep 29, 2026 at 11:21:33AM +0530, Shivang Upadhyay wrote:
> From: Sathvika Vasireddy <sv@linux.ibm.com>
>
> When objtool writes changes back to vmlinux with --ftr-fixup --link,
> libelf recalculates the file layout and inserts padding between
> sections. This corrupts the ELF segment structure, causing kexec to
> fail with:
>
> ELF Note corrupted !
> Cannot determine the file type of vmlinux
>
> This happens because libelf's default behavior assumes it can freely
> rearrange section offsets when writing, which breaks the carefully
> constructed vmlinux layout produced by the linker.
>
> Set ELF_F_LAYOUT after elf_begin() to instruct libelf that the
> application is responsible for the file layout. This prevents libelf
> from inserting padding or repositioning sections while still allowing
> data modifications to be written back.
>
> Signed-off-by: Sathvika Vasireddy <sv@linux.ibm.com>
> Signed-off-by: Shivang Upadhyay <shivangu@linux.ibm.com>
> ---
> tools/objtool/elf.c | 3 +++
> 1 file changed, 3 insertions(+)
>
> diff --git a/tools/objtool/elf.c b/tools/objtool/elf.c
> index a791f4ea6ec1..55c20a993f5d 100644
> --- a/tools/objtool/elf.c
> +++ b/tools/objtool/elf.c
> @@ -1239,6 +1239,9 @@ struct elf *elf_open_read(const char *name, int flags)
> goto err;
> }
>
> + if (opts.ftr_fixup)
> + elf_flagelf(elf->elf, ELF_C_SET, ELF_F_LAYOUT);
So per the previous email; you need this because this is a post-link
pass. As such, anything that has absolute sections would need this. So
should this be conditional on that, rather than ftr?
^ permalink raw reply [flat|nested] 14+ messages in thread
* [PATCH v2 3/6] objtool: Fix "can't find starting instruction" warnings on vmlinux
2026-09-29 5:51 [PATCH v2 0/6] objtool: Fixup alternate feature relative addresses Shivang Upadhyay
2026-09-29 5:51 ` [PATCH v2 1/6] objtool/powerpc: Add build-time fixup of alternate feature branch targets Shivang Upadhyay
2026-09-29 5:51 ` [PATCH v2 2/6] objtool: Set ELF_F_LAYOUT flag to preserve vmlinux segment layout Shivang Upadhyay
@ 2026-09-29 5:51 ` Shivang Upadhyay
2026-09-29 14:12 ` Peter Zijlstra
2026-09-29 14:24 ` Peter Zijlstra
2026-09-29 5:51 ` [PATCH v2 4/6] objtool/powerpc: Skip jump destination analysis and unnanotated intra-function call warnings for --ftr-fixup Shivang Upadhyay
` (2 subsequent siblings)
5 siblings, 2 replies; 14+ messages in thread
From: Shivang Upadhyay @ 2026-09-29 5:51 UTC (permalink / raw)
To: linux-kbuild, linux-kernel, linuxppc-dev
Cc: sv, alexandre.chartre, alexghiti, aliceryhl, ardb, bp, chleroy,
elver, ihor.solodrai, jpoimboe, kees, legion, lossin, maddy,
masahiroy, mpe, nathan, npiggin, nsc, ojeda, peterz, pmladek,
rostedt, tamird, thomas.weissschuh, thuth, yuxuan.zuo,
sourabhjain, Shivang Upadhyay
From: Sathvika Vasireddy <sv@linux.ibm.com>
Objtool throws a lot of can't find starting instruction warnings
when run on vmlinux with --ftr-fixup option.
These warnings are seen because find_insn() function looks for
instructions at offsets that are relative to the start of the section.
In case of individual object files (.o), there are no can't find
starting instruction warnings seen because the actual offset
associated with an instruction is itself a relative offset since the
sections start at offset 0x0.
However, in case of vmlinux, find_insn() function fails to find
instructions at the actual offset associated with an instruction
since the sections in vmlinux do not start at offset 0x0. Due to
this, find_insn() will look for absolute offset and not the relative
offset. This is resulting in a lot of can't find starting instruction
warnings when objtool is run on vmlinux.
To fix this, pass offset that is relative to the start of the section
to find_insn().
find_insn() is also looking for symbols of size 0. But, objtool does
not store empty STT_NOTYPE symbols in the rbtree. Due to this,
for empty symbols, objtool is throwing can't find starting
instruction warnings. Fix this by ignoring symbols that are of
size 0 since objtool does not add them to the rbtree.
Signed-off-by: Sathvika Vasireddy <sv@linux.ibm.com>
Signed-off-by: Shivang Upadhyay <shivangu@linux.ibm.com>
---
tools/objtool/check.c | 17 +++++++++++++----
1 file changed, 13 insertions(+), 4 deletions(-)
diff --git a/tools/objtool/check.c b/tools/objtool/check.c
index 2e875ac9175e..7662e990cb13 100644
--- a/tools/objtool/check.c
+++ b/tools/objtool/check.c
@@ -411,7 +411,7 @@ static int decode_instructions(struct objtool_file *file)
{
struct section *sec;
struct symbol *func;
- unsigned long offset;
+ unsigned long offset, func_off;
struct instruction *insn;
for_each_sec(file->elf, sec) {
@@ -493,17 +493,26 @@ static int decode_instructions(struct objtool_file *file)
if (func->embedded_insn || is_alias_sym(func))
continue;
- if (!find_insn(file, sec, func->offset)) {
+ if (func->len == 0 && is_notype_sym(func))
+ continue;
+
+ func_off = opts.ftr_fixup ?
+ func->offset - sec->sh.sh_addr : func->offset;
+
+ if (!find_insn(file, sec, func_off)) {
ERROR("%s(): can't find starting instruction", func->name);
return -1;
}
- sym_for_each_insn(file, func, insn) {
+ for (insn = find_insn(file, sec, func_off);
+ insn && insn->offset < func_off + func->len;
+ insn = next_insn_same_sec(file, insn)) {
insn->_sym = func;
+
if (is_func_sym(func) &&
insn->type == INSN_ENDBR &&
list_empty(&insn->call_node)) {
- if (insn->offset == func->offset) {
+ if (insn->offset == func_off) {
list_add_tail(&insn->call_node, &file->endbr_list);
file->nr_endbr++;
} else {
--
2.54.0
^ permalink raw reply related [flat|nested] 14+ messages in thread* Re: [PATCH v2 3/6] objtool: Fix "can't find starting instruction" warnings on vmlinux
2026-09-29 5:51 ` [PATCH v2 3/6] objtool: Fix "can't find starting instruction" warnings on vmlinux Shivang Upadhyay
@ 2026-09-29 14:12 ` Peter Zijlstra
2026-09-29 14:24 ` Peter Zijlstra
1 sibling, 0 replies; 14+ messages in thread
From: Peter Zijlstra @ 2026-09-29 14:12 UTC (permalink / raw)
To: Shivang Upadhyay
Cc: linux-kbuild, linux-kernel, linuxppc-dev, sv, alexandre.chartre,
alexghiti, aliceryhl, ardb, bp, chleroy, elver, ihor.solodrai,
jpoimboe, kees, legion, lossin, maddy, masahiroy, mpe, nathan,
npiggin, nsc, ojeda, pmladek, rostedt, tamird, thomas.weissschuh,
thuth, yuxuan.zuo, sourabhjain
On Tue, Sep 29, 2026 at 11:21:34AM +0530, Shivang Upadhyay wrote:
> find_insn() is also looking for symbols of size 0. But, objtool does
> not store empty STT_NOTYPE symbols in the rbtree.
81cf39be3559 ("objtool: Add empty symbols to the symbol tree again")
^ permalink raw reply [flat|nested] 14+ messages in thread* Re: [PATCH v2 3/6] objtool: Fix "can't find starting instruction" warnings on vmlinux
2026-09-29 5:51 ` [PATCH v2 3/6] objtool: Fix "can't find starting instruction" warnings on vmlinux Shivang Upadhyay
2026-09-29 14:12 ` Peter Zijlstra
@ 2026-09-29 14:24 ` Peter Zijlstra
1 sibling, 0 replies; 14+ messages in thread
From: Peter Zijlstra @ 2026-09-29 14:24 UTC (permalink / raw)
To: Shivang Upadhyay
Cc: linux-kbuild, linux-kernel, linuxppc-dev, sv, alexandre.chartre,
alexghiti, aliceryhl, ardb, bp, chleroy, elver, ihor.solodrai,
jpoimboe, kees, legion, lossin, maddy, masahiroy, mpe, nathan,
npiggin, nsc, ojeda, pmladek, rostedt, tamird, thomas.weissschuh,
thuth, yuxuan.zuo, sourabhjain
On Tue, Sep 29, 2026 at 11:21:34AM +0530, Shivang Upadhyay wrote:
> From: Sathvika Vasireddy <sv@linux.ibm.com>
>
> Objtool throws a lot of can't find starting instruction warnings
> when run on vmlinux with --ftr-fixup option.
>
> These warnings are seen because find_insn() function looks for
> instructions at offsets that are relative to the start of the section.
> In case of individual object files (.o), there are no can't find
> starting instruction warnings seen because the actual offset
> associated with an instruction is itself a relative offset since the
> sections start at offset 0x0.
>
> However, in case of vmlinux, find_insn() function fails to find
> instructions at the actual offset associated with an instruction
> since the sections in vmlinux do not start at offset 0x0. Due to
> this, find_insn() will look for absolute offset and not the relative
> offset. This is resulting in a lot of can't find starting instruction
> warnings when objtool is run on vmlinux.
I'm confused; decode_instructions() iterates the section and inserts the
instructions at the exact offset it finds them at. Therefore it should
be able to find them again at that same offset, irrespective of the
actual start, no?
> + if (func->len == 0 && is_notype_sym(func))
> + continue;
> +
> + func_off = opts.ftr_fixup ?
> + func->offset - sec->sh.sh_addr : func->offset;
function offset really should not depend on opts. It should work
irrespective of any option, no?
^ permalink raw reply [flat|nested] 14+ messages in thread
* [PATCH v2 4/6] objtool/powerpc: Skip jump destination analysis and unnanotated intra-function call warnings for --ftr-fixup
2026-09-29 5:51 [PATCH v2 0/6] objtool: Fixup alternate feature relative addresses Shivang Upadhyay
` (2 preceding siblings ...)
2026-09-29 5:51 ` [PATCH v2 3/6] objtool: Fix "can't find starting instruction" warnings on vmlinux Shivang Upadhyay
@ 2026-09-29 5:51 ` Shivang Upadhyay
2026-09-29 14:25 ` Peter Zijlstra
2026-09-29 5:51 ` [PATCH v2 5/6] kbuild: Add objtool integration for PowerPC feature fixups Shivang Upadhyay
2026-09-29 5:51 ` [PATCH v2 6/6] powerpc: Enable build-time feature fixup processing by default Shivang Upadhyay
5 siblings, 1 reply; 14+ messages in thread
From: Shivang Upadhyay @ 2026-09-29 5:51 UTC (permalink / raw)
To: linux-kbuild, linux-kernel, linuxppc-dev
Cc: sv, alexandre.chartre, alexghiti, aliceryhl, ardb, bp, chleroy,
elver, ihor.solodrai, jpoimboe, kees, legion, lossin, maddy,
masahiroy, mpe, nathan, npiggin, nsc, ojeda, peterz, pmladek,
rostedt, tamird, thomas.weissschuh, thuth, yuxuan.zuo,
sourabhjain, Shivang Upadhyay
From: Sathvika Vasireddy <sv@linux.ibm.com>
Objtool is throwing unannotated intra-function call warnings
when run on vmlinux with --ftr-fixup option.
One such example:
vmlinux: warning: objtool: .text+0x3d94:
unannotated intra-function call
.text + 0x3d94 = c000000000008000 + 3d94 = c0000000000081d4
c0000000000081d4: 45 24 02 48 bl c00000000002a618
<system_reset_exception+0x8>
c00000000002a610 <system_reset_exception>:
c00000000002a610: 0e 01 4c 3c addis r2,r12,270
c00000000002a610: R_PPC64_REL16_HA .TOC.
c00000000002a614: f0 6c 42 38 addi r2,r2,27888
c00000000002a614: R_PPC64_REL16_LO .TOC.+0x4
c00000000002a618: a6 02 08 7c mflr r0
This is happening because we should be looking for destination
symbols that are at absolute offsets instead of relative offsets.
After fixing dest_off to point to absolute offset, there are still
a lot of these warnings shown.
In the above example, objtool is computing the destination
offset to be c00000000002a618, which points to a completely
different instruction. find_call_destination() is looking for this
offset and failing. Instead, we should be looking for destination
offset c00000000002a610 which points to system_reset_exception
function.
Even after fixing the way destination offset is computed, and
after looking for dest_off - 0x8 in cases where the original offset
is not found, there are still a lot of unannotated intra-function
call warnings generated. This is due to symbols that are not
properly annotated.
So, for now, as a hack to curb these warnings, do not emit
unannotated intra-function call warnings when objtool is run
with --ftr-fixup option.
Skip add_jump_destinations() and suppress intra-function call
errors in --ftr-fixup mode. The feature fixup pass only needs fixup
entry tables, relocation entries from .__ftr_alternates.text, and
elf_write_insn() to patch branch offsets.
Signed-off-by: Sathvika Vasireddy <sv@linux.ibm.com>
Signed-off-by: Shivang Upadhyay <shivangu@linux.ibm.com>
---
tools/objtool/check.c | 13 +++++++++----
1 file changed, 9 insertions(+), 4 deletions(-)
diff --git a/tools/objtool/check.c b/tools/objtool/check.c
index 7662e990cb13..907dbc8f9b71 100644
--- a/tools/objtool/check.c
+++ b/tools/objtool/check.c
@@ -1693,8 +1693,11 @@ static int add_call_destinations(struct objtool_file *file)
continue;
if (!insn_call_dest(insn)) {
- ERROR_INSN(insn, "unannotated intra-function call");
- return -1;
+ if (!opts.ftr_fixup) {
+ ERROR_INSN(insn, "unannotated intra-function call");
+ return -1;
+ }
+ continue;
}
if (func && !is_func_sym(insn_call_dest(insn))) {
@@ -2661,8 +2664,10 @@ int decode_file(struct objtool_file *file)
return -1;
}
- if (add_jump_destinations(file))
- return -1;
+ if (!opts.ftr_fixup) {
+ if (add_jump_destinations(file))
+ return -1;
+ }
/*
* Must be before add_call_destination(); it changes INSN_CALL to
--
2.54.0
^ permalink raw reply related [flat|nested] 14+ messages in thread* Re: [PATCH v2 4/6] objtool/powerpc: Skip jump destination analysis and unnanotated intra-function call warnings for --ftr-fixup
2026-09-29 5:51 ` [PATCH v2 4/6] objtool/powerpc: Skip jump destination analysis and unnanotated intra-function call warnings for --ftr-fixup Shivang Upadhyay
@ 2026-09-29 14:25 ` Peter Zijlstra
2026-09-30 6:13 ` Shivang Upadhyay
0 siblings, 1 reply; 14+ messages in thread
From: Peter Zijlstra @ 2026-09-29 14:25 UTC (permalink / raw)
To: Shivang Upadhyay
Cc: linux-kbuild, linux-kernel, linuxppc-dev, sv, alexandre.chartre,
alexghiti, aliceryhl, ardb, bp, chleroy, elver, ihor.solodrai,
jpoimboe, kees, legion, lossin, maddy, masahiroy, mpe, nathan,
npiggin, nsc, ojeda, pmladek, rostedt, tamird, thomas.weissschuh,
thuth, yuxuan.zuo, sourabhjain
On Tue, Sep 29, 2026 at 11:21:35AM +0530, Shivang Upadhyay wrote:
> From: Sathvika Vasireddy <sv@linux.ibm.com>
>
> Objtool is throwing unannotated intra-function call warnings
> when run on vmlinux with --ftr-fixup option.
>
> One such example:
>
> vmlinux: warning: objtool: .text+0x3d94:
> unannotated intra-function call
>
> .text + 0x3d94 = c000000000008000 + 3d94 = c0000000000081d4
>
> c0000000000081d4: 45 24 02 48 bl c00000000002a618
> <system_reset_exception+0x8>
>
> c00000000002a610 <system_reset_exception>:
> c00000000002a610: 0e 01 4c 3c addis r2,r12,270
> c00000000002a610: R_PPC64_REL16_HA .TOC.
> c00000000002a614: f0 6c 42 38 addi r2,r2,27888
> c00000000002a614: R_PPC64_REL16_LO .TOC.+0x4
> c00000000002a618: a6 02 08 7c mflr r0
>
> This is happening because we should be looking for destination
> symbols that are at absolute offsets instead of relative offsets.
Again, confused. We run objtool on objects, this is pre-linking, there
are no absolute offsets.
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH v2 4/6] objtool/powerpc: Skip jump destination analysis and unnanotated intra-function call warnings for --ftr-fixup
2026-09-29 14:25 ` Peter Zijlstra
@ 2026-09-30 6:13 ` Shivang Upadhyay
2026-09-30 9:44 ` Peter Zijlstra
0 siblings, 1 reply; 14+ messages in thread
From: Shivang Upadhyay @ 2026-09-30 6:13 UTC (permalink / raw)
To: Peter Zijlstra
Cc: linux-kbuild, linux-kernel, linuxppc-dev, sv, alexandre.chartre,
alexghiti, aliceryhl, ardb, bp, chleroy, elver, ihor.solodrai,
jpoimboe, kees, legion, lossin, maddy, masahiroy, mpe, nathan,
npiggin, nsc, ojeda, pmladek, rostedt, tamird, thomas.weissschuh,
thuth, yuxuan.zuo, sourabhjain
On Tue, 2026-09-29 at 16:25 +0200, Peter Zijlstra wrote:
> > c00000000002a610 <system_reset_exception>:
> > c00000000002a610: 0e 01 4c 3c addis r2,r12,270
> > c00000000002a610: R_PPC64_REL16_HA
> > .TOC.
> > c00000000002a614: f0 6c 42 38 addi r2,r2,27888
> > c00000000002a614: R_PPC64_REL16_LO
> > .TOC.+0x4
> > c00000000002a618: a6 02 08 7c mflr r0
> >
> > This is happening because we should be looking for destination
> > symbols that are at absolute offsets instead of relative offsets.
>
> Again, confused. We run objtool on objects, this is pre-linking,
> there
> are no absolute offsets.
Hi Peter,
This is the special requirement of patching jump assembly instructions
that we need to know where the jump is performed from/to. As per 5/6
objtool is run post link on vmlinux. If handling post-link information
is outside the scope of objtool, please let me know.
Regards,
~Shivang.
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH v2 4/6] objtool/powerpc: Skip jump destination analysis and unnanotated intra-function call warnings for --ftr-fixup
2026-09-30 6:13 ` Shivang Upadhyay
@ 2026-09-30 9:44 ` Peter Zijlstra
2026-10-06 6:14 ` Shivang Upadhyay
0 siblings, 1 reply; 14+ messages in thread
From: Peter Zijlstra @ 2026-09-30 9:44 UTC (permalink / raw)
To: Shivang Upadhyay
Cc: linux-kbuild, linux-kernel, linuxppc-dev, sv, alexandre.chartre,
alexghiti, aliceryhl, ardb, bp, chleroy, elver, ihor.solodrai,
jpoimboe, kees, legion, lossin, maddy, masahiroy, mpe, nathan,
npiggin, nsc, ojeda, pmladek, rostedt, tamird, thomas.weissschuh,
thuth, yuxuan.zuo, sourabhjain
On Wed, Sep 30, 2026 at 11:43:10AM +0530, Shivang Upadhyay wrote:
> On Tue, 2026-09-29 at 16:25 +0200, Peter Zijlstra wrote:
> > > c00000000002a610 <system_reset_exception>:
> > > c00000000002a610: 0e 01 4c 3c addis r2,r12,270
> > > c00000000002a610: R_PPC64_REL16_HA
> > > .TOC.
> > > c00000000002a614: f0 6c 42 38 addi r2,r2,27888
> > > c00000000002a614: R_PPC64_REL16_LO
> > > .TOC.+0x4
> > > c00000000002a618: a6 02 08 7c mflr r0
> > >
> > > This is happening because we should be looking for destination
> > > symbols that are at absolute offsets instead of relative offsets.
> >
> > Again, confused. We run objtool on objects, this is pre-linking,
> > there
> > are no absolute offsets.
> Hi Peter,
>
> This is the special requirement of patching jump assembly instructions
> that we need to know where the jump is performed from/to. As per 5/6
> objtool is run post link on vmlinux. If handling post-link information
> is outside the scope of objtool, please let me know.
I think we can make it work; but this wasn't immediately obvious. Also
I'm still struggling to understand what exactly you're doing -- I'm not
well versed in the PPC details and have no idea what this ftr thing
really is and your patches don't really explain anything much at all.
(Gemini is suggesting this is all somewhat similar to the x86 RIP
relative fixup we do for alternatives, but your case is more 'fun').
Anyway, I would much rather objtool learns how to deal with absolute
sections rather than making things depend on a 'random' ftr option. That
is, if we need conditional code, have it be because the secion has
non-zero address, not because ftr option or somesuch.
But noting that, can't we simply change:
decode_instructions()
hash_add(file->insn_hash, &insn->hash, sec_offset_hash(sec, insn->offset));
to take sh_addr into account? I mean, when unlinked, it'll be 0 so
nothing changes, but when already linked, it'll get you the absolute
value and then you don't need that fixup later on, or am I missing some
details?
So from where I'm at, please:
- teach objtool about absolute sections, not ftr specials
- expand changelog to actually explain what these ftr things are and
how they work and what the actual problem is we're solving, so we
don't need to employ LLMs to understand patches and all that :-)
Does that sound reasonable?
^ permalink raw reply [flat|nested] 14+ messages in thread* Re: [PATCH v2 4/6] objtool/powerpc: Skip jump destination analysis and unnanotated intra-function call warnings for --ftr-fixup
2026-09-30 9:44 ` Peter Zijlstra
@ 2026-10-06 6:14 ` Shivang Upadhyay
0 siblings, 0 replies; 14+ messages in thread
From: Shivang Upadhyay @ 2026-10-06 6:14 UTC (permalink / raw)
To: Peter Zijlstra
Cc: linux-kbuild, linux-kernel, linuxppc-dev, sv, alexandre.chartre,
alexghiti, aliceryhl, ardb, bp, chleroy, elver, ihor.solodrai,
jpoimboe, kees, legion, lossin, maddy, masahiroy, mpe, nathan,
npiggin, nsc, ojeda, pmladek, rostedt, tamird, thomas.weissschuh,
thuth, yuxuan.zuo, sourabhjain
On Wed, 2026-09-30 at 11:44 +0200, Peter Zijlstra wrote:
> On Wed, Sep 30, 2026 at 11:43:10AM +0530, Shivang Upadhyay wrote:
> > On Tue, 2026-09-29 at 16:25 +0200, Peter Zijlstra wrote:
> > > > c00000000002a610 <system_reset_exception>:
> > > > c00000000002a610: 0e 01 4c 3c addis r2,r12,270
> > > > c00000000002a610: R_PPC64_REL16_HA
> > > > .TOC.
> > > > c00000000002a614: f0 6c 42 38 addi r2,r2,27888
> > > > c00000000002a614: R_PPC64_REL16_LO
> > > > .TOC.+0x4
> > > > c00000000002a618: a6 02 08 7c mflr r0
> > > >
> > > > This is happening because we should be looking for destination
> > > > symbols that are at absolute offsets instead of relative
> > > > offsets.
> > >
> > > Again, confused. We run objtool on objects, this is pre-linking,
> > > there
> > > are no absolute offsets.
> > Hi Peter,
> >
> > This is the special requirement of patching jump assembly
> > instructions
> > that we need to know where the jump is performed from/to. As per
> > 5/6
> > objtool is run post link on vmlinux. If handling post-link
> > information
> > is outside the scope of objtool, please let me know.
>
> I think we can make it work; but this wasn't immediately obvious.
> Also
> I'm still struggling to understand what exactly you're doing -- I'm
> not
> well versed in the PPC details and have no idea what this ftr thing
> really is and your patches don't really explain anything much at all.
>
> (Gemini is suggesting this is all somewhat similar to the x86 RIP
> relative fixup we do for alternatives, but your case is more 'fun').
>
Hi Peter,
Sorry for the delayed response.
I think I can explain the feature fixup mechanism and the problem we're
trying to solve more clearly in the cover letter.
Here is a basic example of what we're trying to achieve.
GEN_COMMON data_access
ld r4,_DSISR(r1)
addi r3,r1,STACK_INT_FRAME_REGS
andis. r0,r4,DSISR_DABRMATCH@h
bne- 1f
#ifdef CONFIG_PPC_64S_HASH_MMU
BEGIN_MMU_FTR_SECTION
bl CFUNC(do_hash_fault)
MMU_FTR_SECTION_ELSE
bl CFUNC(do_page_fault)
ALT_MMU_FTR_SECTION_END_IFCLR(MMU_FTR_TYPE_RADIX)
#else
bl CFUNC(do_page_fault)
#endif
b interrupt_return_srr
This is the implementation of the data_access exception handler on
ppc64le. Depending on whether the machine is using the hash or radix
MMU, we need to execute a different fault handler. The choice is made
at runtime based on the CPU's feature bits.
The assembly macros therefore generate code for both possible cases at
build time, and the feature-fixup mechanism later patches the code so
that only the appropriate path is executed.
The problem is that the linker does not know about this later patching
when it resolves branch relocations.
For example, consider:
feat_loc:
...
BEGIN_MMU_FTR_SECTION
...
loc_a:
bl CFUNC(main_feature)
...
MMU_FTR_SECTION_ELSE
...
loc_b:
bl CFUNC(alt_feature)
...
When linking this code, the linker will encode
main_feature - loc_a at loc_a and alt_feature - loc_b at loc_b at two
bl instructions ablove.
However, alt_feature - loc_b is not the offset that we ultimately need
from the alt branch. When the feature fixup is applied, the instruction
at loc_a is replaced with the alternative instruction, so the branch
needs to encode (alt_feature - loc_a) jump.
This distinction matters because the branch displacement has to fit in
the range representable by the 32-bit PowerPC branch instruction.
Depending on where feat_loc, main_feature, and alt_feature end up after
linking, the linker-generated displacement can therefore be different
from the displacement that is actually needed after the feature fixup.
In some layouts this can result in either a build-time failure or, more
importantly, an invalid branch at runtime.
What we're trying to do with the build-time pass is detect these cases
and prepare the branch relocations for the code as it will actually
exist after feature patching. At minimum, it should allow us to detect
an impossible branch offset at build time rather than discovering it
only after the feature fixup is applied at runtime.
> Anyway, I would much rather objtool learns how to deal with absolute
> sections rather than making things depend on a 'random' ftr option.
> That
> is, if we need conditional code, have it be because the secion has
> non-zero address, not because ftr option or somesuch.
>
> But noting that, can't we simply change:
>
> decode_instructions()
> hash_add(file->insn_hash, &insn->hash, sec_offset_hash(sec, insn-
> >offset));
>
> to take sh_addr into account? I mean, when unlinked, it'll be 0 so
> nothing changes, but when already linked, it'll get you the absolute
> value and then you don't need that fixup later on, or am I missing
> some
> details?
>
> So from where I'm at, please:
>
> - teach objtool about absolute sections, not ftr specials
Sure I will try to rework these patches towards that.
>
> - expand changelog to actually explain what these ftr things are and
> how they work and what the actual problem is we're solving, so we
> don't need to employ LLMs to understand patches and all that :-)
>
> Does that sound reasonable?
Yes.
Thanks
~Shivang.
^ permalink raw reply [flat|nested] 14+ messages in thread
* [PATCH v2 5/6] kbuild: Add objtool integration for PowerPC feature fixups
2026-09-29 5:51 [PATCH v2 0/6] objtool: Fixup alternate feature relative addresses Shivang Upadhyay
` (3 preceding siblings ...)
2026-09-29 5:51 ` [PATCH v2 4/6] objtool/powerpc: Skip jump destination analysis and unnanotated intra-function call warnings for --ftr-fixup Shivang Upadhyay
@ 2026-09-29 5:51 ` Shivang Upadhyay
2026-09-29 5:51 ` [PATCH v2 6/6] powerpc: Enable build-time feature fixup processing by default Shivang Upadhyay
5 siblings, 0 replies; 14+ messages in thread
From: Shivang Upadhyay @ 2026-09-29 5:51 UTC (permalink / raw)
To: linux-kbuild, linux-kernel, linuxppc-dev
Cc: sv, alexandre.chartre, alexghiti, aliceryhl, ardb, bp, chleroy,
elver, ihor.solodrai, jpoimboe, kees, legion, lossin, maddy,
masahiroy, mpe, nathan, npiggin, nsc, ojeda, peterz, pmladek,
rostedt, tamird, thomas.weissschuh, thuth, yuxuan.zuo,
sourabhjain, Shivang Upadhyay
From: Sathvika Vasireddy <sv@linux.ibm.com>
Add build system support for PowerPC feature fixup processing:
- Add HAVE_OBJTOOL_FTR_FIXUP config option for architectures that
support
build-time feature fixup processing
- Integrate objtool feature fixup processing into vmlinux build
Suggested-by: Masahiro Yamada <masahiroy@kernel.org>
Signed-off-by: Sathvika Vasireddy <sv@linux.ibm.com>
Acked-by: Nicolas Schier <nsc@kernel.org> # kbuild
Signed-off-by: Shivang Upadhyay <shivangu@linux.ibm.com>
---
Makefile | 7 +++++++
scripts/Makefile.lib | 4 ++--
scripts/Makefile.vmlinux | 3 ++-
3 files changed, 11 insertions(+), 3 deletions(-)
diff --git a/Makefile b/Makefile
index 6b8b812f23b9..363cad32fb26 100644
--- a/Makefile
+++ b/Makefile
@@ -1566,6 +1566,13 @@ ifdef CONFIG_OBJTOOL
prepare: tools/objtool
endif
+# CONFIG_OBJTOOL and CONFIG_HAVE_OBJTOOL_FTR_FIXUP are unrelated, separate
+# options. It was integrated in objtool in order to borrow the elf parser,
+# but this is different from how the other objtool commands are used.
+ifdef CONFIG_HAVE_OBJTOOL_FTR_FIXUP
+prepare: tools/objtool
+endif
+
ifdef CONFIG_BPF
ifdef CONFIG_DEBUG_INFO_BTF
prepare: tools/bpf/resolve_btfids
diff --git a/scripts/Makefile.lib b/scripts/Makefile.lib
index 0a4fdd8bd975..efcedeb207b7 100644
--- a/scripts/Makefile.lib
+++ b/scripts/Makefile.lib
@@ -182,10 +182,10 @@ cpp_flags = -Wp,-MMD,$(depfile) $(NOSTDINC_FLAGS) $(LINUXINCLUDE) \
ld_flags = $(KBUILD_LDFLAGS) $(ldflags-y) $(LDFLAGS_$(@F))
-ifdef CONFIG_OBJTOOL
-
objtool := $(objtree)/tools/objtool/objtool
+ifdef CONFIG_OBJTOOL
+
objtool-args-$(CONFIG_HAVE_JUMP_LABEL_HACK) += --hacks=jump_label
objtool-args-$(CONFIG_HAVE_NOINSTR_HACK) += --hacks=noinstr
objtool-args-$(CONFIG_MITIGATION_CALL_DEPTH_TRACKING) += --hacks=skylake
diff --git a/scripts/Makefile.vmlinux b/scripts/Makefile.vmlinux
index fcae1e432d9a..a1bef0638ecb 100644
--- a/scripts/Makefile.vmlinux
+++ b/scripts/Makefile.vmlinux
@@ -65,7 +65,8 @@ ARCH_POSTLINK := $(wildcard $(srctree)/arch/$(SRCARCH)/Makefile.postlink)
# Final link of vmlinux with optional arch pass after final link
cmd_link_vmlinux = \
$< "$(LD)" "$(KBUILD_LDFLAGS)" "$(LDFLAGS_vmlinux)" "$@"; \
- $(if $(ARCH_POSTLINK), $(MAKE) -f $(ARCH_POSTLINK) $@, true)
+ $(if $(ARCH_POSTLINK), $(MAKE) -f $(ARCH_POSTLINK) $@, true); \
+ $(if $(CONFIG_HAVE_OBJTOOL_FTR_FIXUP), $(objtool) --ftr-fixup --link $@, true)
targets += vmlinux.unstripped .vmlinux.export.o
vmlinux.unstripped: scripts/link-vmlinux.sh vmlinux.o .vmlinux.export.o $(KBUILD_LDS) FORCE
--
2.54.0
^ permalink raw reply related [flat|nested] 14+ messages in thread* [PATCH v2 6/6] powerpc: Enable build-time feature fixup processing by default
2026-09-29 5:51 [PATCH v2 0/6] objtool: Fixup alternate feature relative addresses Shivang Upadhyay
` (4 preceding siblings ...)
2026-09-29 5:51 ` [PATCH v2 5/6] kbuild: Add objtool integration for PowerPC feature fixups Shivang Upadhyay
@ 2026-09-29 5:51 ` Shivang Upadhyay
5 siblings, 0 replies; 14+ messages in thread
From: Shivang Upadhyay @ 2026-09-29 5:51 UTC (permalink / raw)
To: linux-kbuild, linux-kernel, linuxppc-dev
Cc: sv, alexandre.chartre, alexghiti, aliceryhl, ardb, bp, chleroy,
elver, ihor.solodrai, jpoimboe, kees, legion, lossin, maddy,
masahiroy, mpe, nathan, npiggin, nsc, ojeda, peterz, pmladek,
rostedt, tamird, thomas.weissschuh, thuth, yuxuan.zuo,
sourabhjain, Shivang Upadhyay
From: Sathvika Vasireddy <sv@linux.ibm.com>
Enable HAVE_OBJTOOL_FTR_FIXUP by default on PowerPC architecture.
- Remove runtime branch translation logic from patch_alt_instruction()
- Add --emit-relocs linker flags for post-link fixup processing
- Update ftr_alt section attributes to include executable flag
- Strip the --emit-relocs relocation sections (.rel*) from the final
vmlinux after processing
Co-developed-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Sathvika Vasireddy <sv@linux.ibm.com>
Signed-off-by: Shivang Upadhyay <shivangu@linux.ibm.com>
---
arch/powerpc/Kconfig | 3 +++
arch/powerpc/Makefile | 5 +++++
arch/powerpc/include/asm/feature-fixups.h | 2 +-
arch/powerpc/kernel/vmlinux.lds.S | 8 ++++++--
arch/powerpc/lib/feature-fixups.c | 12 ------------
scripts/Makefile.vmlinux | 8 ++++++--
6 files changed, 21 insertions(+), 17 deletions(-)
diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig
index 2580e27e4328..d9056f35da9f 100644
--- a/arch/powerpc/Kconfig
+++ b/arch/powerpc/Kconfig
@@ -23,6 +23,9 @@ config 64BIT
bool
default y if PPC64
+config HAVE_OBJTOOL_FTR_FIXUP
+ def_bool y
+
config LIVEPATCH_64
def_bool PPC64
depends on LIVEPATCH
diff --git a/arch/powerpc/Makefile b/arch/powerpc/Makefile
index 9385db478c59..269ed76a40c6 100644
--- a/arch/powerpc/Makefile
+++ b/arch/powerpc/Makefile
@@ -112,6 +112,11 @@ LDFLAGS_vmlinux-$(CONFIG_RELOCATABLE) := -pie --no-dynamic-linker
LDFLAGS_vmlinux-$(CONFIG_RELOCATABLE) += -z notext
LDFLAGS_vmlinux := $(LDFLAGS_vmlinux-y)
+# --emit-relocs required for post-link fixup of alternate feature
+# text section relocations.
+LDFLAGS_vmlinux += --emit-relocs
+KBUILD_LDFLAGS_MODULE += --emit-relocs
+
ifdef CONFIG_PPC64
ifndef CONFIG_PPC_KERNEL_PCREL
# -mcmodel=medium breaks modules because it uses 32bit offsets from
diff --git a/arch/powerpc/include/asm/feature-fixups.h b/arch/powerpc/include/asm/feature-fixups.h
index 756a6c694018..d6ae92a292ec 100644
--- a/arch/powerpc/include/asm/feature-fixups.h
+++ b/arch/powerpc/include/asm/feature-fixups.h
@@ -32,7 +32,7 @@
#define FTR_SECTION_ELSE_NESTED(label) \
label##2: \
- .pushsection __ftr_alt_##label,"a"; \
+ .pushsection __ftr_alt_##label, "ax"; \
.align 2; \
label##3:
diff --git a/arch/powerpc/kernel/vmlinux.lds.S b/arch/powerpc/kernel/vmlinux.lds.S
index 8fc11d6565bf..1a2d7c2d32f1 100644
--- a/arch/powerpc/kernel/vmlinux.lds.S
+++ b/arch/powerpc/kernel/vmlinux.lds.S
@@ -99,8 +99,8 @@ SECTIONS
.text : AT(ADDR(.text) - LOAD_OFFSET) {
ALIGN_FUNCTION();
#endif
- /* careful! __ftr_alt_* sections need to be close to .text */
- *(.text.hot .text.hot.* TEXT_MAIN .text.fixup .text.unlikely .text.unlikely.* .fixup __ftr_alt_* .ref.text);
+ *(.text.hot .text.hot.* TEXT_MAIN .text.fixup .text.unlikely
+ .text.unlikely.* .fixup .ref.text);
*(.tramp.ftrace.text);
NOINSTR_TEXT
SCHED_TEXT
@@ -267,6 +267,10 @@ SECTIONS
_einittext = .;
} :text
+ .__ftr_alternates.text : AT(ADDR(.__ftr_alternates.text) - LOAD_OFFSET) {
+ *(__ftr_alt*);
+ }
+
/* .exit.text is discarded at runtime, not link time,
* to deal with references from __bug_table
*/
diff --git a/arch/powerpc/lib/feature-fixups.c b/arch/powerpc/lib/feature-fixups.c
index 587c8cf1230f..269e992b1631 100644
--- a/arch/powerpc/lib/feature-fixups.c
+++ b/arch/powerpc/lib/feature-fixups.c
@@ -53,22 +53,10 @@ static u32 *calc_addr(struct fixup_entry *fcur, long offset)
static int patch_alt_instruction(u32 *src, u32 *dest, u32 *alt_start, u32 *alt_end)
{
- int err;
ppc_inst_t instr;
instr = ppc_inst_read(src);
- if (instr_is_relative_branch(ppc_inst_read(src))) {
- u32 *target = (u32 *)branch_target(src);
-
- /* Branch within the section doesn't need translating */
- if (target < alt_start || target > alt_end) {
- err = translate_branch(&instr, dest, src);
- if (err)
- return 1;
- }
- }
-
raw_patch_instruction(dest, instr);
return 0;
diff --git a/scripts/Makefile.vmlinux b/scripts/Makefile.vmlinux
index a1bef0638ecb..66e5d58a6ce8 100644
--- a/scripts/Makefile.vmlinux
+++ b/scripts/Makefile.vmlinux
@@ -82,11 +82,15 @@ endif
# vmlinux
# ---------------------------------------------------------------------------
+# These configurations require vmlinux.unstripped to be linked with
+# '--emit-relocs', which need to be stripped from the final vmlinux.
+uses-emit-relocs := $(or $(CONFIG_ARCH_VMLINUX_NEEDS_RELOCS),$(CONFIG_HAVE_OBJTOOL_FTR_FIXUP))
+
remove-section-y := .modinfo
-remove-section-$(CONFIG_ARCH_VMLINUX_NEEDS_RELOCS) += '.rel*' '!.rel*.dyn'
+remove-section-$(uses-emit-relocs) += '.rel*' '!.rel*.dyn'
# for compatibility with binutils < 2.32
# https://sourceware.org/git/?p=binutils-gdb.git;a=commit;h=c12d9fa2afe7abcbe407a00e15719e1a1350c2a7
-remove-section-$(CONFIG_ARCH_VMLINUX_NEEDS_RELOCS) += '.rel.*'
+remove-section-$(uses-emit-relocs) += '.rel.*'
remove-symbols := -w --strip-unneeded-symbol='__mod_device_table__*'
--
2.54.0
^ permalink raw reply related [flat|nested] 14+ messages in thread