2019-05-19 13:51:43 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2017-07-11 15:33:42 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2017 Josh Poimboeuf <jpoimboe@redhat.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
2023-03-01 15:13:07 +00:00
|
|
|
#include <linux/objtool_types.h>
|
2020-09-04 15:30:27 +00:00
|
|
|
#include <asm/orc_types.h>
|
|
|
|
|
2020-11-12 23:03:32 +00:00
|
|
|
#include <objtool/check.h>
|
|
|
|
#include <objtool/warn.h>
|
|
|
|
#include <objtool/endianness.h>
|
2017-07-11 15:33:42 +00:00
|
|
|
|
2021-06-24 09:41:01 +00:00
|
|
|
static int init_orc_entry(struct orc_entry *orc, struct cfi_state *cfi,
|
|
|
|
struct instruction *insn)
|
2017-07-11 15:33:42 +00:00
|
|
|
{
|
2020-12-17 21:02:42 +00:00
|
|
|
struct cfi_reg *bp = &cfi->regs[CFI_BP];
|
2017-07-11 15:33:42 +00:00
|
|
|
|
2020-12-17 21:02:42 +00:00
|
|
|
memset(orc, 0, sizeof(*orc));
|
2017-07-11 15:33:42 +00:00
|
|
|
|
2021-06-24 09:41:01 +00:00
|
|
|
if (!cfi) {
|
2023-03-01 15:13:12 +00:00
|
|
|
/*
|
|
|
|
* This is usually either unreachable nops/traps (which don't
|
|
|
|
* trigger unreachable instruction warnings), or
|
|
|
|
* STACK_FRAME_NON_STANDARD functions.
|
|
|
|
*/
|
|
|
|
orc->type = ORC_TYPE_UNDEFINED;
|
2021-06-24 09:41:01 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2023-03-01 15:13:10 +00:00
|
|
|
switch (cfi->type) {
|
2023-03-01 15:13:12 +00:00
|
|
|
case UNWIND_HINT_TYPE_UNDEFINED:
|
|
|
|
orc->type = ORC_TYPE_UNDEFINED;
|
|
|
|
return 0;
|
|
|
|
case UNWIND_HINT_TYPE_END_OF_STACK:
|
|
|
|
orc->type = ORC_TYPE_END_OF_STACK;
|
|
|
|
return 0;
|
2023-03-01 15:13:10 +00:00
|
|
|
case UNWIND_HINT_TYPE_CALL:
|
|
|
|
orc->type = ORC_TYPE_CALL;
|
|
|
|
break;
|
|
|
|
case UNWIND_HINT_TYPE_REGS:
|
|
|
|
orc->type = ORC_TYPE_REGS;
|
|
|
|
break;
|
|
|
|
case UNWIND_HINT_TYPE_REGS_PARTIAL:
|
|
|
|
orc->type = ORC_TYPE_REGS_PARTIAL;
|
|
|
|
break;
|
|
|
|
default:
|
2023-04-12 19:03:17 +00:00
|
|
|
WARN_INSN(insn, "unknown unwind hint type %d", cfi->type);
|
2023-03-01 15:13:10 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2023-02-16 20:34:41 +00:00
|
|
|
orc->signal = cfi->signal;
|
2018-05-18 06:47:12 +00:00
|
|
|
|
2020-12-17 21:02:42 +00:00
|
|
|
switch (cfi->cfa.base) {
|
|
|
|
case CFI_SP:
|
|
|
|
orc->sp_reg = ORC_REG_SP;
|
|
|
|
break;
|
|
|
|
case CFI_SP_INDIRECT:
|
|
|
|
orc->sp_reg = ORC_REG_SP_INDIRECT;
|
|
|
|
break;
|
|
|
|
case CFI_BP:
|
|
|
|
orc->sp_reg = ORC_REG_BP;
|
|
|
|
break;
|
|
|
|
case CFI_BP_INDIRECT:
|
|
|
|
orc->sp_reg = ORC_REG_BP_INDIRECT;
|
|
|
|
break;
|
|
|
|
case CFI_R10:
|
|
|
|
orc->sp_reg = ORC_REG_R10;
|
|
|
|
break;
|
|
|
|
case CFI_R13:
|
|
|
|
orc->sp_reg = ORC_REG_R13;
|
|
|
|
break;
|
|
|
|
case CFI_DI:
|
|
|
|
orc->sp_reg = ORC_REG_DI;
|
|
|
|
break;
|
|
|
|
case CFI_DX:
|
|
|
|
orc->sp_reg = ORC_REG_DX;
|
|
|
|
break;
|
|
|
|
default:
|
2023-04-12 19:03:17 +00:00
|
|
|
WARN_INSN(insn, "unknown CFA base reg %d", cfi->cfa.base);
|
2020-12-17 21:02:42 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2017-07-11 15:33:42 +00:00
|
|
|
|
2020-12-17 21:02:42 +00:00
|
|
|
switch (bp->base) {
|
|
|
|
case CFI_UNDEFINED:
|
|
|
|
orc->bp_reg = ORC_REG_UNDEFINED;
|
|
|
|
break;
|
|
|
|
case CFI_CFA:
|
|
|
|
orc->bp_reg = ORC_REG_PREV_SP;
|
|
|
|
break;
|
|
|
|
case CFI_BP:
|
|
|
|
orc->bp_reg = ORC_REG_BP;
|
|
|
|
break;
|
|
|
|
default:
|
2023-04-12 19:03:17 +00:00
|
|
|
WARN_INSN(insn, "unknown BP base reg %d", bp->base);
|
2020-12-17 21:02:42 +00:00
|
|
|
return -1;
|
2017-07-11 15:33:42 +00:00
|
|
|
}
|
|
|
|
|
2020-12-17 21:02:42 +00:00
|
|
|
orc->sp_offset = cfi->cfa.offset;
|
|
|
|
orc->bp_offset = bp->offset;
|
|
|
|
|
2017-07-11 15:33:42 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-12-17 21:02:42 +00:00
|
|
|
static int write_orc_entry(struct elf *elf, struct section *orc_sec,
|
2021-03-26 15:12:07 +00:00
|
|
|
struct section *ip_sec, unsigned int idx,
|
2020-12-17 21:02:42 +00:00
|
|
|
struct section *insn_sec, unsigned long insn_off,
|
|
|
|
struct orc_entry *o)
|
2017-07-11 15:33:42 +00:00
|
|
|
{
|
|
|
|
struct orc_entry *orc;
|
|
|
|
|
|
|
|
/* populate ORC data */
|
2020-12-17 21:02:42 +00:00
|
|
|
orc = (struct orc_entry *)orc_sec->data->d_buf + idx;
|
2017-07-11 15:33:42 +00:00
|
|
|
memcpy(orc, o, sizeof(*orc));
|
2022-11-14 17:57:47 +00:00
|
|
|
orc->sp_offset = bswap_if_needed(elf, orc->sp_offset);
|
|
|
|
orc->bp_offset = bswap_if_needed(elf, orc->bp_offset);
|
2017-07-11 15:33:42 +00:00
|
|
|
|
objtool: Rename rela to reloc
Before supporting additional relocation types rename the relevant
types and functions from "rela" to "reloc". This work be done with
the following regex:
sed -e 's/struct rela/struct reloc/g' \
-e 's/\([_\*]\)rela\(s\{0,1\}\)/\1reloc\2/g' \
-e 's/tmprela\(s\{0,1\}\)/tmpreloc\1/g' \
-e 's/relasec/relocsec/g' \
-e 's/rela_list/reloc_list/g' \
-e 's/rela_hash/reloc_hash/g' \
-e 's/add_rela/add_reloc/g' \
-e 's/rela->/reloc->/g' \
-e '/rela[,\.]/{ s/\([^\.>]\)rela\([\.,]\)/\1reloc\2/g ; }' \
-e 's/rela =/reloc =/g' \
-e 's/relas =/relocs =/g' \
-e 's/relas\[/relocs[/g' \
-e 's/relaname =/relocname =/g' \
-e 's/= rela\;/= reloc\;/g' \
-e 's/= relas\;/= relocs\;/g' \
-e 's/= relaname\;/= relocname\;/g' \
-e 's/, rela)/, reloc)/g' \
-e 's/\([ @]\)rela\([ "]\)/\1reloc\2/g' \
-e 's/ rela$/ reloc/g' \
-e 's/, relaname/, relocname/g' \
-e 's/sec->rela/sec->reloc/g' \
-e 's/(\(!\{0,1\}\)rela/(\1reloc/g' \
-i \
arch.h \
arch/x86/decode.c \
check.c \
check.h \
elf.c \
elf.h \
orc_gen.c \
special.c
Notable exceptions which complicate the regex include gelf_*
library calls and standard/expected section names which still use
"rela" because they encode the type of relocation expected. Also, keep
"rela" in the struct because it encodes a specific type of relocation
we currently expect.
It will eventually turn into a member of an anonymous union when a
susequent patch adds implicit addend, or "rel", relocation support.
Signed-off-by: Matt Helsley <mhelsley@vmware.com>
Signed-off-by: Josh Poimboeuf <jpoimboe@redhat.com>
2020-05-29 21:01:13 +00:00
|
|
|
/* populate reloc for ip */
|
2023-05-30 17:20:59 +00:00
|
|
|
if (!elf_init_reloc_text_sym(elf, ip_sec, idx * sizeof(int), idx,
|
|
|
|
insn_sec, insn_off))
|
2017-07-11 15:33:42 +00:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-12-17 21:02:42 +00:00
|
|
|
struct orc_list_entry {
|
|
|
|
struct list_head list;
|
|
|
|
struct orc_entry orc;
|
|
|
|
struct section *insn_sec;
|
|
|
|
unsigned long insn_off;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int orc_list_add(struct list_head *orc_list, struct orc_entry *orc,
|
|
|
|
struct section *sec, unsigned long offset)
|
|
|
|
{
|
|
|
|
struct orc_list_entry *entry = malloc(sizeof(*entry));
|
|
|
|
|
|
|
|
if (!entry) {
|
|
|
|
WARN("malloc failed");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
entry->orc = *orc;
|
|
|
|
entry->insn_sec = sec;
|
|
|
|
entry->insn_off = offset;
|
|
|
|
|
|
|
|
list_add_tail(&entry->list, orc_list);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
objtool: Support stack layout changes in alternatives
The ORC unwinder showed a warning [1] which revealed the stack layout
didn't match what was expected. The problem was that paravirt patching
had replaced "CALL *pv_ops.irq.save_fl" with "PUSHF;POP". That changed
the stack layout between the PUSHF and the POP, so unwinding from an
interrupt which occurred between those two instructions would fail.
Part of the agreed upon solution was to rework the custom paravirt
patching code to use alternatives instead, since objtool already knows
how to read alternatives (and converging runtime patching infrastructure
is always a good thing anyway). But the main problem still remains,
which is that runtime patching can change the stack layout.
Making stack layout changes in alternatives was disallowed with commit
7117f16bf460 ("objtool: Fix ORC vs alternatives"), but now that paravirt
is going to be doing it, it needs to be supported.
One way to do so would be to modify the ORC table when the code gets
patched. But ORC is simple -- a good thing! -- and it's best to leave
it alone.
Instead, support stack layout changes by "flattening" all possible stack
states (CFI) from parallel alternative code streams into a single set of
linear states. The only necessary limitation is that CFI conflicts are
disallowed at all possible instruction boundaries.
For example, this scenario is allowed:
Alt1 Alt2 Alt3
0x00 CALL *pv_ops.save_fl CALL xen_save_fl PUSHF
0x01 POP %RAX
0x02 NOP
...
0x05 NOP
...
0x07 <insn>
The unwind information for offset-0x00 is identical for all 3
alternatives. Similarly offset-0x05 and higher also are identical (and
the same as 0x00). However offset-0x01 has deviating CFI, but that is
only relevant for Alt3, neither of the other alternative instruction
streams will ever hit that offset.
This scenario is NOT allowed:
Alt1 Alt2
0x00 CALL *pv_ops.save_fl PUSHF
0x01 NOP6
...
0x07 NOP POP %RAX
The problem here is that offset-0x7, which is an instruction boundary in
both possible instruction patch streams, has two conflicting stack
layouts.
[ The above examples were stolen from Peter Zijlstra. ]
The new flattened CFI array is used both for the detection of conflicts
(like the second example above) and the generation of linear ORC
entries.
BTW, another benefit of these changes is that, thanks to some related
cleanups (new fake nops and alt_group struct) objtool can finally be rid
of fake jumps, which were a constant source of headaches.
[1] https://lkml.kernel.org/r/20201111170536.arx2zbn4ngvjoov7@treble
Cc: Shinichiro Kawasaki <shinichiro.kawasaki@wdc.com>
Signed-off-by: Josh Poimboeuf <jpoimboe@redhat.com>
2020-12-18 20:26:21 +00:00
|
|
|
static unsigned long alt_group_len(struct alt_group *alt_group)
|
|
|
|
{
|
|
|
|
return alt_group->last_insn->offset +
|
|
|
|
alt_group->last_insn->len -
|
|
|
|
alt_group->first_insn->offset;
|
|
|
|
}
|
|
|
|
|
2020-12-17 21:02:42 +00:00
|
|
|
int orc_create(struct objtool_file *file)
|
2017-07-11 15:33:42 +00:00
|
|
|
{
|
2021-03-26 15:12:07 +00:00
|
|
|
struct section *sec, *orc_sec;
|
2020-12-17 21:02:42 +00:00
|
|
|
unsigned int nr = 0, idx = 0;
|
|
|
|
struct orc_list_entry *entry;
|
|
|
|
struct list_head orc_list;
|
2017-07-11 15:33:42 +00:00
|
|
|
|
2023-03-01 15:13:12 +00:00
|
|
|
struct orc_entry null = { .type = ORC_TYPE_UNDEFINED };
|
2017-07-11 15:33:42 +00:00
|
|
|
|
2020-12-17 21:02:42 +00:00
|
|
|
/* Build a deduplicated list of ORC entries: */
|
|
|
|
INIT_LIST_HEAD(&orc_list);
|
2017-07-11 15:33:42 +00:00
|
|
|
for_each_sec(file, sec) {
|
2020-12-17 21:02:42 +00:00
|
|
|
struct orc_entry orc, prev_orc = {0};
|
|
|
|
struct instruction *insn;
|
|
|
|
bool empty = true;
|
|
|
|
|
2017-07-11 15:33:42 +00:00
|
|
|
if (!sec->text)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
sec_for_each_insn(file, sec, insn) {
|
objtool: Support stack layout changes in alternatives
The ORC unwinder showed a warning [1] which revealed the stack layout
didn't match what was expected. The problem was that paravirt patching
had replaced "CALL *pv_ops.irq.save_fl" with "PUSHF;POP". That changed
the stack layout between the PUSHF and the POP, so unwinding from an
interrupt which occurred between those two instructions would fail.
Part of the agreed upon solution was to rework the custom paravirt
patching code to use alternatives instead, since objtool already knows
how to read alternatives (and converging runtime patching infrastructure
is always a good thing anyway). But the main problem still remains,
which is that runtime patching can change the stack layout.
Making stack layout changes in alternatives was disallowed with commit
7117f16bf460 ("objtool: Fix ORC vs alternatives"), but now that paravirt
is going to be doing it, it needs to be supported.
One way to do so would be to modify the ORC table when the code gets
patched. But ORC is simple -- a good thing! -- and it's best to leave
it alone.
Instead, support stack layout changes by "flattening" all possible stack
states (CFI) from parallel alternative code streams into a single set of
linear states. The only necessary limitation is that CFI conflicts are
disallowed at all possible instruction boundaries.
For example, this scenario is allowed:
Alt1 Alt2 Alt3
0x00 CALL *pv_ops.save_fl CALL xen_save_fl PUSHF
0x01 POP %RAX
0x02 NOP
...
0x05 NOP
...
0x07 <insn>
The unwind information for offset-0x00 is identical for all 3
alternatives. Similarly offset-0x05 and higher also are identical (and
the same as 0x00). However offset-0x01 has deviating CFI, but that is
only relevant for Alt3, neither of the other alternative instruction
streams will ever hit that offset.
This scenario is NOT allowed:
Alt1 Alt2
0x00 CALL *pv_ops.save_fl PUSHF
0x01 NOP6
...
0x07 NOP POP %RAX
The problem here is that offset-0x7, which is an instruction boundary in
both possible instruction patch streams, has two conflicting stack
layouts.
[ The above examples were stolen from Peter Zijlstra. ]
The new flattened CFI array is used both for the detection of conflicts
(like the second example above) and the generation of linear ORC
entries.
BTW, another benefit of these changes is that, thanks to some related
cleanups (new fake nops and alt_group struct) objtool can finally be rid
of fake jumps, which were a constant source of headaches.
[1] https://lkml.kernel.org/r/20201111170536.arx2zbn4ngvjoov7@treble
Cc: Shinichiro Kawasaki <shinichiro.kawasaki@wdc.com>
Signed-off-by: Josh Poimboeuf <jpoimboe@redhat.com>
2020-12-18 20:26:21 +00:00
|
|
|
struct alt_group *alt_group = insn->alt_group;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!alt_group) {
|
2021-06-24 09:41:01 +00:00
|
|
|
if (init_orc_entry(&orc, insn->cfi, insn))
|
objtool: Support stack layout changes in alternatives
The ORC unwinder showed a warning [1] which revealed the stack layout
didn't match what was expected. The problem was that paravirt patching
had replaced "CALL *pv_ops.irq.save_fl" with "PUSHF;POP". That changed
the stack layout between the PUSHF and the POP, so unwinding from an
interrupt which occurred between those two instructions would fail.
Part of the agreed upon solution was to rework the custom paravirt
patching code to use alternatives instead, since objtool already knows
how to read alternatives (and converging runtime patching infrastructure
is always a good thing anyway). But the main problem still remains,
which is that runtime patching can change the stack layout.
Making stack layout changes in alternatives was disallowed with commit
7117f16bf460 ("objtool: Fix ORC vs alternatives"), but now that paravirt
is going to be doing it, it needs to be supported.
One way to do so would be to modify the ORC table when the code gets
patched. But ORC is simple -- a good thing! -- and it's best to leave
it alone.
Instead, support stack layout changes by "flattening" all possible stack
states (CFI) from parallel alternative code streams into a single set of
linear states. The only necessary limitation is that CFI conflicts are
disallowed at all possible instruction boundaries.
For example, this scenario is allowed:
Alt1 Alt2 Alt3
0x00 CALL *pv_ops.save_fl CALL xen_save_fl PUSHF
0x01 POP %RAX
0x02 NOP
...
0x05 NOP
...
0x07 <insn>
The unwind information for offset-0x00 is identical for all 3
alternatives. Similarly offset-0x05 and higher also are identical (and
the same as 0x00). However offset-0x01 has deviating CFI, but that is
only relevant for Alt3, neither of the other alternative instruction
streams will ever hit that offset.
This scenario is NOT allowed:
Alt1 Alt2
0x00 CALL *pv_ops.save_fl PUSHF
0x01 NOP6
...
0x07 NOP POP %RAX
The problem here is that offset-0x7, which is an instruction boundary in
both possible instruction patch streams, has two conflicting stack
layouts.
[ The above examples were stolen from Peter Zijlstra. ]
The new flattened CFI array is used both for the detection of conflicts
(like the second example above) and the generation of linear ORC
entries.
BTW, another benefit of these changes is that, thanks to some related
cleanups (new fake nops and alt_group struct) objtool can finally be rid
of fake jumps, which were a constant source of headaches.
[1] https://lkml.kernel.org/r/20201111170536.arx2zbn4ngvjoov7@treble
Cc: Shinichiro Kawasaki <shinichiro.kawasaki@wdc.com>
Signed-off-by: Josh Poimboeuf <jpoimboe@redhat.com>
2020-12-18 20:26:21 +00:00
|
|
|
return -1;
|
|
|
|
if (!memcmp(&prev_orc, &orc, sizeof(orc)))
|
|
|
|
continue;
|
|
|
|
if (orc_list_add(&orc_list, &orc, sec,
|
|
|
|
insn->offset))
|
|
|
|
return -1;
|
|
|
|
nr++;
|
|
|
|
prev_orc = orc;
|
|
|
|
empty = false;
|
2020-12-17 21:02:42 +00:00
|
|
|
continue;
|
objtool: Support stack layout changes in alternatives
The ORC unwinder showed a warning [1] which revealed the stack layout
didn't match what was expected. The problem was that paravirt patching
had replaced "CALL *pv_ops.irq.save_fl" with "PUSHF;POP". That changed
the stack layout between the PUSHF and the POP, so unwinding from an
interrupt which occurred between those two instructions would fail.
Part of the agreed upon solution was to rework the custom paravirt
patching code to use alternatives instead, since objtool already knows
how to read alternatives (and converging runtime patching infrastructure
is always a good thing anyway). But the main problem still remains,
which is that runtime patching can change the stack layout.
Making stack layout changes in alternatives was disallowed with commit
7117f16bf460 ("objtool: Fix ORC vs alternatives"), but now that paravirt
is going to be doing it, it needs to be supported.
One way to do so would be to modify the ORC table when the code gets
patched. But ORC is simple -- a good thing! -- and it's best to leave
it alone.
Instead, support stack layout changes by "flattening" all possible stack
states (CFI) from parallel alternative code streams into a single set of
linear states. The only necessary limitation is that CFI conflicts are
disallowed at all possible instruction boundaries.
For example, this scenario is allowed:
Alt1 Alt2 Alt3
0x00 CALL *pv_ops.save_fl CALL xen_save_fl PUSHF
0x01 POP %RAX
0x02 NOP
...
0x05 NOP
...
0x07 <insn>
The unwind information for offset-0x00 is identical for all 3
alternatives. Similarly offset-0x05 and higher also are identical (and
the same as 0x00). However offset-0x01 has deviating CFI, but that is
only relevant for Alt3, neither of the other alternative instruction
streams will ever hit that offset.
This scenario is NOT allowed:
Alt1 Alt2
0x00 CALL *pv_ops.save_fl PUSHF
0x01 NOP6
...
0x07 NOP POP %RAX
The problem here is that offset-0x7, which is an instruction boundary in
both possible instruction patch streams, has two conflicting stack
layouts.
[ The above examples were stolen from Peter Zijlstra. ]
The new flattened CFI array is used both for the detection of conflicts
(like the second example above) and the generation of linear ORC
entries.
BTW, another benefit of these changes is that, thanks to some related
cleanups (new fake nops and alt_group struct) objtool can finally be rid
of fake jumps, which were a constant source of headaches.
[1] https://lkml.kernel.org/r/20201111170536.arx2zbn4ngvjoov7@treble
Cc: Shinichiro Kawasaki <shinichiro.kawasaki@wdc.com>
Signed-off-by: Josh Poimboeuf <jpoimboe@redhat.com>
2020-12-18 20:26:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Alternatives can have different stack layout
|
|
|
|
* possibilities (but they shouldn't conflict).
|
|
|
|
* Instead of traversing the instructions, use the
|
|
|
|
* alt_group's flattened byte-offset-addressed CFI
|
|
|
|
* array.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < alt_group_len(alt_group); i++) {
|
|
|
|
struct cfi_state *cfi = alt_group->cfi[i];
|
|
|
|
if (!cfi)
|
|
|
|
continue;
|
2021-06-24 09:41:01 +00:00
|
|
|
/* errors are reported on the original insn */
|
|
|
|
if (init_orc_entry(&orc, cfi, insn))
|
objtool: Support stack layout changes in alternatives
The ORC unwinder showed a warning [1] which revealed the stack layout
didn't match what was expected. The problem was that paravirt patching
had replaced "CALL *pv_ops.irq.save_fl" with "PUSHF;POP". That changed
the stack layout between the PUSHF and the POP, so unwinding from an
interrupt which occurred between those two instructions would fail.
Part of the agreed upon solution was to rework the custom paravirt
patching code to use alternatives instead, since objtool already knows
how to read alternatives (and converging runtime patching infrastructure
is always a good thing anyway). But the main problem still remains,
which is that runtime patching can change the stack layout.
Making stack layout changes in alternatives was disallowed with commit
7117f16bf460 ("objtool: Fix ORC vs alternatives"), but now that paravirt
is going to be doing it, it needs to be supported.
One way to do so would be to modify the ORC table when the code gets
patched. But ORC is simple -- a good thing! -- and it's best to leave
it alone.
Instead, support stack layout changes by "flattening" all possible stack
states (CFI) from parallel alternative code streams into a single set of
linear states. The only necessary limitation is that CFI conflicts are
disallowed at all possible instruction boundaries.
For example, this scenario is allowed:
Alt1 Alt2 Alt3
0x00 CALL *pv_ops.save_fl CALL xen_save_fl PUSHF
0x01 POP %RAX
0x02 NOP
...
0x05 NOP
...
0x07 <insn>
The unwind information for offset-0x00 is identical for all 3
alternatives. Similarly offset-0x05 and higher also are identical (and
the same as 0x00). However offset-0x01 has deviating CFI, but that is
only relevant for Alt3, neither of the other alternative instruction
streams will ever hit that offset.
This scenario is NOT allowed:
Alt1 Alt2
0x00 CALL *pv_ops.save_fl PUSHF
0x01 NOP6
...
0x07 NOP POP %RAX
The problem here is that offset-0x7, which is an instruction boundary in
both possible instruction patch streams, has two conflicting stack
layouts.
[ The above examples were stolen from Peter Zijlstra. ]
The new flattened CFI array is used both for the detection of conflicts
(like the second example above) and the generation of linear ORC
entries.
BTW, another benefit of these changes is that, thanks to some related
cleanups (new fake nops and alt_group struct) objtool can finally be rid
of fake jumps, which were a constant source of headaches.
[1] https://lkml.kernel.org/r/20201111170536.arx2zbn4ngvjoov7@treble
Cc: Shinichiro Kawasaki <shinichiro.kawasaki@wdc.com>
Signed-off-by: Josh Poimboeuf <jpoimboe@redhat.com>
2020-12-18 20:26:21 +00:00
|
|
|
return -1;
|
|
|
|
if (!memcmp(&prev_orc, &orc, sizeof(orc)))
|
|
|
|
continue;
|
|
|
|
if (orc_list_add(&orc_list, &orc, insn->sec,
|
|
|
|
insn->offset + i))
|
|
|
|
return -1;
|
|
|
|
nr++;
|
|
|
|
prev_orc = orc;
|
|
|
|
empty = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Skip to the end of the alt_group */
|
|
|
|
insn = alt_group->last_insn;
|
2017-07-11 15:33:42 +00:00
|
|
|
}
|
|
|
|
|
2020-12-17 21:02:42 +00:00
|
|
|
/* Add a section terminator */
|
|
|
|
if (!empty) {
|
2021-08-22 22:50:37 +00:00
|
|
|
orc_list_add(&orc_list, &null, sec, sec->sh.sh_size);
|
2020-12-17 21:02:42 +00:00
|
|
|
nr++;
|
|
|
|
}
|
2017-07-11 15:33:42 +00:00
|
|
|
}
|
2020-12-17 21:02:42 +00:00
|
|
|
if (!nr)
|
|
|
|
return 0;
|
2017-07-11 15:33:42 +00:00
|
|
|
|
2020-12-17 21:02:42 +00:00
|
|
|
/* Create .orc_unwind, .orc_unwind_ip and .rela.orc_unwind_ip sections: */
|
|
|
|
sec = find_section_by_name(file->elf, ".orc_unwind");
|
|
|
|
if (sec) {
|
|
|
|
WARN("file already has .orc_unwind section, skipping");
|
|
|
|
return -1;
|
|
|
|
}
|
2023-05-30 17:20:54 +00:00
|
|
|
orc_sec = elf_create_section(file->elf, ".orc_unwind",
|
2020-12-17 21:02:42 +00:00
|
|
|
sizeof(struct orc_entry), nr);
|
|
|
|
if (!orc_sec)
|
|
|
|
return -1;
|
2017-07-11 15:33:42 +00:00
|
|
|
|
2023-05-30 17:20:59 +00:00
|
|
|
sec = elf_create_section_pair(file->elf, ".orc_unwind_ip", sizeof(int), nr, nr);
|
2017-12-30 20:43:32 +00:00
|
|
|
if (!sec)
|
|
|
|
return -1;
|
2017-07-11 15:33:42 +00:00
|
|
|
|
2020-12-17 21:02:42 +00:00
|
|
|
/* Write ORC entries to sections: */
|
|
|
|
list_for_each_entry(entry, &orc_list, list) {
|
2021-03-26 15:12:07 +00:00
|
|
|
if (write_orc_entry(file->elf, orc_sec, sec, idx++,
|
2020-12-17 21:02:42 +00:00
|
|
|
entry->insn_sec, entry->insn_off,
|
|
|
|
&entry->orc))
|
|
|
|
return -1;
|
2017-07-11 15:33:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|