objtool vs retpoline
Subsystems (7)
Peter Zijlstra
maintainerv2 cover objtool vs retpoline
Hi,
Based on Alexandre's patches, here's a few that go on top of tip/objtool/core.
With these patches on objtool can completely understand retpolines and RSB stuffing, which means it can emit valid ORC unwind information for them, which in turn means we can now unwind through a retpoline.
New since last time:
- 1-3, alternatives vs ORC unwind
- 7-9: implement some suggestions from Julien
- addressed feedback
Peter Zijlstra
maintainerPATCH v2 1/14 objtool: Allow branches within the same alternative.
From: Alexandre Chartre <[email protected]>
Currently objtool prevents any branch to an alternative. While preventing branching from the outside to the middle of an alternative makes perfect sense, branching within the same alternative should be allowed. To do so, identify each alternative and check that a branch to an alternative comes from the same alternative.
--- tools/objtool/check.c | 26 ++++++++++++++++++++------ tools/objtool/check.h | 3 ++- 2 files changed, 22 insertions(+), 7 deletions(-)
tools/objtool/check.c +20 -6
@@ -770,7 +770,9 @@ static int handle_group_alt(struct objto struct instruction *orig_insn, struct instruction **new_insn) { +static unsigned int alt_group_next_index =1 ;struct instruction *last_orig_insn, *last_new_insn, *insn, *fake_jump =NULL ; +unsigned int alt_group = alt_group_next_index++;unsigned long dest_off; last_orig_insn =NULL ;
@@ -779,7 +781,7 @@ static int handle_group_alt(struct objtoif (insn->offset >= special_alt->orig_off + special_alt->orig_len)break ; - insn->alt_group = true; + insn->alt_group = alt_group; last_orig_insn = insn; }
@@ -813,6 +815,7 @@ static int handle_group_alt(struct objto } last_new_insn =NULL ; + alt_group = alt_group_next_index++; insn = *new_insn;sec_for_each_insn_from (file, insn) {if (insn->offset >= special_alt->new_off + special_alt->new_len)
@@ -822,6 +825,7 @@ static int handle_group_alt(struct objto insn->ignore = orig_insn->ignore_alts; insn->func = orig_insn->func; + insn->alt_group = alt_group;/* * Since alternative replacement code is copy/pasted by the
@@ -2163,6 +2167,15 @@ static int validate_return(struct symbolreturn 0 ; } +static bool is_branch_to_alternative (struct instruction *from, +struct instruction *to) +{ +if (!from || !to->alt_group || !list_empty (&to->alts)) +return false; + +return (from->alt_group != to->alt_group); +} +/* * Follow the branch starting at the given instruction, and recursively follow * any other branches (jumps). Meanwhile, track the frame pointer state at
@@ -2170,6 +2183,7 @@ static int validate_return(struct symbol* tools/objtool/Documentation/stack-validation.txt. */ static int validate_branch (struct objtool_file *file,struct symbol *func, +struct instruction *from,struct instruction *insn,struct insn_state state) {struct alternative *alt;
@@ -2180,7 +2194,7 @@ static int validate_branch(struct objtoo sec = insn->sec; -if (insn->alt_group &&list_empty (&insn->alts)) { +if (is_branch_to_alternative (from, insn)) {WARN_FUNC ("don't know how to handle branch to middle of alternative instruction group" , sec, insn->offset);return 1 ;
@@ -2227,7 +2241,7 @@ static int validate_branch(struct objtooif (alt->skip_orig) skip_orig = true; - ret =validate_branch (file, func, alt->insn, state); + ret =validate_branch (file, func,NULL , alt->insn, state);if (ret) {if (backtrace)BT_FUNC ("(alt)" , insn);
@@ -2271,7 +2285,7 @@ static int validate_branch(struct objtoo }else if (insn->jump_dest) { ret =validate_branch (file, func, - insn->jump_dest, state); + insn, insn->jump_dest, state);if (ret) {if (backtrace)BT_FUNC ("(branch)" , insn);
@@ -2402,7 +2416,7 @@ static int validate_unwind_hints(structwhile (&insn->list != &file->insn_list && (!sec || insn->sec == sec)) {if (insn->hint && !insn->visited) { - ret =validate_branch (file, insn->func, insn, state); + ret =validate_branch (file, insn->func,NULL , insn, state);if (ret && backtrace)BT_FUNC ("<=== (hint)" , insn); warnings += ret;
@@ -2543,7 +2557,7 @@ static int validate_symbol(struct objtoo state->uaccess = sym->uaccess_safe; - ret =validate_branch (file, insn->func, insn, *state); + ret =validate_branch (file, insn->func,NULL , insn, *state);if (ret && backtrace)BT_FUNC ("<=== (sym)" , insn);return ret;
tools/objtool/check.h +2 -1
@@ -30,12 +30,13 @@ struct instruction {unsigned int len;enum insn_type type;unsigned long immediate; -bool alt_group, dead_end, ignore, ignore_alts; +bool dead_end, ignore, ignore_alts;bool hint;bool retpoline_safe;s8 instr;u8 visited;u8 ret_offset; +int alt_group;struct symbol *call_dest;struct instruction *jump_dest;struct instruction *first_jump_src;
Re: [PATCH v2 01/14] objtool: Allow branches within the same alternative.
Quoted 11 lines · Peter Zijlstra
From: Alexandre Chartre <[email protected]>
Currently objtool prevents any branch to an alternative. While preventing branching from the outside to the middle of an alternative makes perfect sense, branching within the same alternative should be allowed. To do so, identify each alternative and check that a branch to an alternative comes from the same alternative.
Signed-off-by Alexandre Chartre <[email protected]>Signed-off-by Peter Zijlstra (Intel) <[email protected]>
I still don't like this patch, other than the "alt_group = alt_group_next_index++" thing as a prerequisite for the next patch.
Instead of all this, let's just get rid of the
"don't know how to handle branch to middle of alternative instruction group"
warning, which I think we decided is useless and not worth the effort anyway.
Quoted 130 lines
--- tools/objtool/check.c | 26 ++++++++++++++++++++------ tools/objtool/check.h | 3 ++- 2 files changed, 22 insertions(+), 7 deletions(-)tools/objtool/check.c +20
-6@@ -770,7 +770,9 @@ static int handle_group_alt(struct objto struct instruction *orig_insn, struct instruction **new_insn) { +static unsigned int alt_group_next_index =1 ;struct instruction *last_orig_insn, *last_new_insn, *insn, *fake_jump =NULL ; +unsigned int alt_group = alt_group_next_index++;unsigned long dest_off; last_orig_insn =NULL ;@@ -779,7 +781,7 @@ static int handle_group_alt(struct objtoif (insn->offset >= special_alt->orig_off + special_alt->orig_len)break ; - insn->alt_group = true; + insn->alt_group = alt_group; last_orig_insn = insn; }@@ -813,6 +815,7 @@ static int handle_group_alt(struct objto } last_new_insn =NULL ; + alt_group = alt_group_next_index++; insn = *new_insn;sec_for_each_insn_from (file, insn) {if (insn->offset >= special_alt->new_off + special_alt->new_len)@@ -822,6 +825,7 @@ static int handle_group_alt(struct objto insn->ignore = orig_insn->ignore_alts; insn->func = orig_insn->func; + insn->alt_group = alt_group;/* * Since alternative replacement code is copy/pasted by the @@ -2163,6 +2167,15 @@ static int validate_return(struct symbolreturn 0 ; } +static bool is_branch_to_alternative (struct instruction *from, +struct instruction *to) +{ +if (!from || !to->alt_group || !list_empty (&to->alts)) +return false; + +return (from->alt_group != to->alt_group); +} +/* * Follow the branch starting at the given instruction, and recursively follow * any other branches (jumps). Meanwhile, track the frame pointer state at @@ -2170,6 +2183,7 @@ static int validate_return(struct symbol* tools/objtool/Documentation/stack-validation.txt. */ static int validate_branch (struct objtool_file *file,struct symbol *func, +struct instruction *from,struct instruction *insn,struct insn_state state) {struct alternative *alt;@@ -2180,7 +2194,7 @@ static int validate_branch(struct objtoo sec = insn->sec; -if (insn->alt_group &&list_empty (&insn->alts)) { +if (is_branch_to_alternative (from, insn)) {WARN_FUNC ("don't know how to handle branch to middle of alternative instruction group" , sec, insn->offset);return 1 ;@@ -2227,7 +2241,7 @@ static int validate_branch(struct objtooif (alt->skip_orig) skip_orig = true; - ret =validate_branch (file, func, alt->insn, state); + ret =validate_branch (file, func,NULL , alt->insn, state);if (ret) {if (backtrace)BT_FUNC ("(alt)" , insn);@@ -2271,7 +2285,7 @@ static int validate_branch(struct objtoo }else if (insn->jump_dest) { ret =validate_branch (file, func, - insn->jump_dest, state); + insn, insn->jump_dest, state);if (ret) {if (backtrace)BT_FUNC ("(branch)" , insn);@@ -2402,7 +2416,7 @@ static int validate_unwind_hints(structwhile (&insn->list != &file->insn_list && (!sec || insn->sec == sec)) {if (insn->hint && !insn->visited) { - ret =validate_branch (file, insn->func, insn, state); + ret =validate_branch (file, insn->func,NULL , insn, state);if (ret && backtrace)BT_FUNC ("<=== (hint)" , insn); warnings += ret;@@ -2543,7 +2557,7 @@ static int validate_symbol(struct objtoo state->uaccess = sym->uaccess_safe; - ret =validate_branch (file, insn->func, insn, *state); + ret =validate_branch (file, insn->func,NULL , insn, *state);if (ret && backtrace)BT_FUNC ("<=== (sym)" , insn);return ret;tools/objtool/check.h +2
-1@@ -30,12 +30,13 @@ struct instruction {unsigned int len;enum insn_type type;unsigned long immediate; -bool alt_group, dead_end, ignore, ignore_alts; +bool dead_end, ignore, ignore_alts;bool hint;bool retpoline_safe;s8 instr;u8 visited;u8 ret_offset; +int alt_group;struct symbol *call_dest;struct instruction *jump_dest;struct instruction *first_jump_src;
Signature · 1 line
Josh
Peter Zijlstra
maintainerPATCH v2 2/14 objtool: Fix ORC vs alternatives
In reply to Peter ZijlstraJann reported that (for instance) entry_64.o:general_protection has very odd ORC data:
0000000000000f40 <general_protection>:
#######sp:sp+8 bp:(und) type:iret end:0
f40: 90 nop
#######sp:(und) bp:(und) type:call end:0
f41: 90 nop
f42: 90 nop
#######sp:sp+8 bp:(und) type:iret end:0
f43: e8 a8 01 00 00 callq 10f0 <error_entry>
#######sp:sp+0 bp:(und) type:regs end:0
f48: f6 84 24 88 00 00 00 testb $0x3,0x88(%rsp)
f4f: 03
f50: 74 00 je f52 <general_protection+0x12>
f52: 48 89 e7 mov %rsp,%rdi
f55: 48 8b 74 24 78 mov 0x78(%rsp),%rsi
f5a: 48 c7 44 24 78 ff ff movq $0xffffffffffffffff,0x78(%rsp)
f61: ff ff
f63: e8 00 00 00 00 callq f68 <general_protection+0x28>
f68: e9 73 02 00 00 jmpq 11e0 <error_exit> #######sp:(und) bp:(und) type:call end:0
f6d: 0f 1f 00 nopl (%rax)
Note the entry at 0xf41. Josh found this was the result of commit:
764eef4b109a ("objtool: Rewrite alt->skip_orig")
Due to the early return in validate_branch() we no longer set insn->cfi of the original instruction stream (the NOPs at 0xf41 and 0xf42) and we'll end up with the above weirdness.
In other discussions we realized alternatives should be ORC invariant; that is, due to there being only a single ORC table, it must be valid for all alternatives. The easiest way to ensure this is to not allow any stack modifications in alternatives.
When we enforce this latter observation, we get the property that the whole alternative must have the same CFI, which we can employ to fix the former report.
--- tools/objtool/Documentation/stack-validation.txt | 7 ++++ tools/objtool/check.c | 34 ++++++++++++++++++++++- 2 files changed, 40 insertions(+), 1 deletion(-)
tools/objtool/Documentation/stack-validation.txt +7 -0
@@ -315,6 +315,13 @@ they mean, and suggestions for how to fi function tracing inserts additional calls, which is not obvious from the sources). +10. file.o: warning: func()+0x5c: alternative modifies stack + + This means that an alternative includes instructions that modify the + stack. The problem is that there is only one ORC unwind table, this means + that the ORC unwind entries must be valid for each of the alternatives. + The easiest way to enforce this is to ensure alternative do not contain + any ORC entries, which in turn implies the above constraint. If the error doesn't seem to make sense, it could be a bug in objtool. Feel free to ask the objtool maintainer for help.
tools/objtool/check.c +33 -1
@@ -2001,6 +2001,11 @@ static int handle_insn_ops(struct instrulist_for_each_entry (op, &insn->stack_ops, list) {int res; +if (insn->alt_group) { +WARN_FUNC ("alternative modifies stack" , insn->sec, insn->offset); +return -1 ; + } + res =update_cfi_state (insn, &state->cfi, op);if (res)return res;
@@ -2177,6 +2182,30 @@ static bool is_branch_to_alternative(str }/* +* Alternatives should not contain any ORC entries, this in turn means they +* should not contain any CFI ops, which implies all instructions should have +* the same same CFI state. +* +* It is possible to constuct alternatives that have unreachable holes that go +* unreported (because they're NOPs), such holes would result in CFI_UNDEFINED +* states which then results in ORC entries, which we just said we didn't want. +* +* Avoid them by copying the CFI entry of the first instruction into the whole +* alternative. +*/ +static void fill_alternative_cfi (struct objtool_file *file,struct instruction *insn) +{ +struct instruction *first_insn = insn; +int alt_group = insn->alt_group; + +sec_for_each_insn_continue (file, insn) { +if (insn->alt_group != alt_group) +break ; + insn->cfi = first_insn->cfi; + } +} + +/* * Follow the branch starting at the given instruction, and recursively follow * any other branches (jumps). Meanwhile, track the frame pointer state at * each instruction and validate all the rules described in
@@ -2234,7 +2263,7 @@ static int validate_branch(struct objtoo insn->visited |= visited; -if (!insn->ignore_alts) { +if (!insn->ignore_alts && !list_empty (&insn->alts)) {bool skip_orig = false;list_for_each_entry (alt, &insn->alts, list) {
@@ -2249,6 +2278,9 @@ static int validate_branch(struct objtoo } } +if (insn->alt_group) +fill_alternative_cfi (file, insn); +if (skip_orig)return 0 ; }
Re: [PATCH v2 02/14] objtool: Fix ORC vs alternatives
Quoted 52 lines · Peter Zijlstra
Jann reported that (for instance) entry_64.o:general_protection has very odd ORC data:
0000000000000f40<general_protection>:
#######sp:sp+8 bp:(und) type:iret end:0
f40: 90 nop
#######sp:(und) bp:(und) type:call end:0f41: 90 nop f42: 90 nop #######sp:sp+8 bp:(und) type:iret end:0 f43: e8 a8 01 00 00 callq 10f0 <error_entry> #######sp:sp+0 bp:(und) type:regs end:0 f48: f6 84 24 88 00 00 00 testb $0x3,0x88(%rsp) f4f: 03 f50: 74 00 je f52 <general_protection+0x12> f52: 48 89 e7 mov %rsp,%rdi f55: 48 8b 74 24 78 mov 0x78(%rsp),%rsi f5a: 48 c7 44 24 78 ff ff movq $0xffffffffffffffff,0x78(%rsp) f61: ff ff f63: e8 00 00 00 00 callq f68 <general_protection+0x28> f68: e9 73 02 00 00 jmpq 11e0 <error_exit>#######sp:(und) bp:(und) type:call end:0
f6d: 0f 1f 00 nopl (%rax)Note the entry at
0xf41. Josh found this was the result of commit:
764eef4b109a("objtool: Rewritealt->skip_orig")Due to the early return in
validate_branch()we no longer setinsn->cfiof the original instruction stream (the NOPs at0xf41and0xf42) and we'll end up with the above weirdness.In other discussions we realized alternatives should be ORC invariant; that is, due to there being only a single ORC table, it must be valid for all alternatives. The easiest way to ensure this is to not allow any stack modifications in alternatives.
When we enforce this latter observation, we get the property that the whole alternative must have the same CFI, which we can employ to fix the former report.
Fixes 764eef4b109a ("objtool: Rewrite alt->skip_orig")Reported-by Jann Horn <[email protected]>Signed-off-by Peter Zijlstra (Intel) <[email protected]>--- tools/objtool/Documentation/stack-validation.txt | 7 ++++ tools/objtool/check.c | 34 ++++++++++++++++++++++- 2 files changed, 40 insertions(+), 1 deletion(-)
tools/objtool/Documentation/stack-validation.txt they mean, and suggestions for how to fi · line 323
Quoted 9 lines
tools/objtool/Documentation/stack-validation.txt +6
-0@@ -315,6 +315,13 @@ they mean, and suggestions for how to fi function tracing inserts additional calls, which is not obvious from the sources). +10. file.o: warning: func()+0x5c: alternative modifies stack + + This means that an alternative includes instructions that modify the + stack. The problem is that there is only one ORC unwind table, this means + that the ORC unwind entries must be valid for each of the alternatives. + The easiest way to enforce this is to ensure alternative do not contain
"alternatives"
Signature · 1 line
Josh
Re: [PATCH v2 02/14] objtool: Fix ORC vs alternatives
In reply to Peter ZijlstraQuoted 95 lines · Peter Zijlstra
Jann reported that (for instance) entry_64.o:general_protection has very odd ORC data:
0000000000000f40<general_protection>:
#######sp:sp+8 bp:(und) type:iret end:0
f40: 90 nop
#######sp:(und) bp:(und) type:call end:0f41: 90 nop f42: 90 nop #######sp:sp+8 bp:(und) type:iret end:0 f43: e8 a8 01 00 00 callq 10f0 <error_entry> #######sp:sp+0 bp:(und) type:regs end:0 f48: f6 84 24 88 00 00 00 testb $0x3,0x88(%rsp) f4f: 03 f50: 74 00 je f52 <general_protection+0x12> f52: 48 89 e7 mov %rsp,%rdi f55: 48 8b 74 24 78 mov 0x78(%rsp),%rsi f5a: 48 c7 44 24 78 ff ff movq $0xffffffffffffffff,0x78(%rsp) f61: ff ff f63: e8 00 00 00 00 callq f68 <general_protection+0x28> f68: e9 73 02 00 00 jmpq 11e0 <error_exit>#######sp:(und) bp:(und) type:call end:0
f6d: 0f 1f 00 nopl (%rax)Note the entry at
0xf41. Josh found this was the result of commit:
764eef4b109a("objtool: Rewritealt->skip_orig")Due to the early return in
validate_branch()we no longer setinsn->cfiof the original instruction stream (the NOPs at0xf41and0xf42) and we'll end up with the above weirdness.In other discussions we realized alternatives should be ORC invariant; that is, due to there being only a single ORC table, it must be valid for all alternatives. The easiest way to ensure this is to not allow any stack modifications in alternatives.
When we enforce this latter observation, we get the property that the whole alternative must have the same CFI, which we can employ to fix the former report.
Fixes 764eef4b109a ("objtool: Rewrite alt->skip_orig")Reported-by Jann Horn <[email protected]>Signed-off-by Peter Zijlstra (Intel) <[email protected]>--- tools/objtool/Documentation/stack-validation.txt | 7 ++++ tools/objtool/check.c | 34 ++++++++++++++++++++++- 2 files changed, 40 insertions(+), 1 deletion(-)tools/objtool/Documentation/stack-validation.txt +7
-0@@ -315,6 +315,13 @@ they mean, and suggestions for how to fi function tracing inserts additional calls, which is not obvious from the sources). +10. file.o: warning: func()+0x5c: alternative modifies stack + + This means that an alternative includes instructions that modify the + stack. The problem is that there is only one ORC unwind table, this means + that the ORC unwind entries must be valid for each of the alternatives. + The easiest way to enforce this is to ensure alternative do not contain + any ORC entries, which in turn implies the above constraint. If the error doesn't seem to make sense, it could be a bug in objtool. Feel free to ask the objtool maintainer for help.tools/objtool/check.c +17
-0@@ -2001,6 +2001,11 @@ static int handle_insn_ops(struct instrulist_for_each_entry (op, &insn->stack_ops, list) {int res; +if (insn->alt_group) { +WARN_FUNC ("alternative modifies stack" , insn->sec, insn->offset); +return -1 ; + } + res =update_cfi_state (insn, &state->cfi, op);if (res)return res;@@ -2177,6 +2182,30 @@ static bool is_branch_to_alternative(str }/* +* Alternatives should not contain any ORC entries, this in turn means they +* should not contain any CFI ops, which implies all instructions should have +* the same same CFI state. +* +* It is possible to constuct alternatives that have unreachable holes that go +* unreported (because they're NOPs), such holes would result in CFI_UNDEFINED +* states which then results in ORC entries, which we just said we didn't want. +* +* Avoid them by copying the CFI entry of the first instruction into the whole +* alternative. +*/ +static void fill_alternative_cfi (struct objtool_file *file,struct instruction *insn)
tools/objtool/check.c static bool is_branch_to_alternative(str · line 2206
Quoted 10 lines
tools/objtool/check.c +10
-0+{ +struct instruction *first_insn = insn; +int alt_group = insn->alt_group; + +sec_for_each_insn_continue (file, insn) { +if (insn->alt_group != alt_group) +break ; + insn->cfi = first_insn->cfi; + } +}
If I am reading this and previous patch correctly...
The function would copy cfi only to "orig" alternative (its insn->alts is non-empty, orig_insn->alt_group differs from new_insn->alt_group), right? Would it make sense to do the same for "new" alternative, because of the invariant? It seems to me it is not processed anywhere that way.
Am I missing something? Whenever I try to read all this alternatives handling in objtool, I get lost pretty soon.
Quoted 15 lines
tools/objtool/check.c +3
-1+ +/* * Follow the branch starting at the given instruction, and recursively follow * any other branches (jumps). Meanwhile, track the frame pointer state at * each instruction and validate all the rules described in @@ -2234,7 +2263,7 @@ static int validate_branch(struct objtoo insn->visited |= visited; -if (!insn->ignore_alts) { +if (!insn->ignore_alts && !list_empty (&insn->alts)) {bool skip_orig = false;list_for_each_entry (alt, &insn->alts, list) {
tools/objtool/check.c static int validate_branch(struct objtoo · line 2283
Quoted 6 lines
tools/objtool/check.c +3
-0@@ -2249,6 +2278,9 @@ static int validate_branch(struct objtoo } } +if (insn->alt_group) +fill_alternative_cfi (file, insn); +
fill_alternative_cfi() is called here only for orig_insn, isn't it?
tools/objtool/check.c static int validate_branch(struct objtoo · line 2286
Quoted 3 lines
tools/objtool/check.c +0
-0if (skip_orig)return 0 ; }
Miroslav
Peter Zijlstra
maintainerRe: [PATCH v2 02/14] objtool: Fix ORC vs alternatives
Quoted 27 lines · Miroslav Benes
Quoted 13 lines · Peter Zijlstra
/*
+ * Alternatives should not contain any ORC entries, this in turn means they
+ * should not contain any CFI ops, which implies all instructions should have
+ * the same same CFI state.
+ *
+ * It is possible to constuct alternatives that have unreachable holes that go
+ * unreported (because they're NOPs), such holes would result inCFI_UNDEFINED
+ * states which then results in ORC entries, which we just said we didn't want.
+ *
+ * Avoid them by copying the CFI entry of the first instruction into the whole
+ * alternative.
+ */tools/objtool/check.c +1
-0+static void fill_alternative_cfi (struct objtool_file *file,struct instruction *insn)tools/objtool/check.c static bool is_branch_to_alternative(str · line 2206
Quoted 10 lines
tools/objtool/check.c +10
-0+{ +struct instruction *first_insn = insn; +int alt_group = insn->alt_group; + +sec_for_each_insn_continue (file, insn) { +if (insn->alt_group != alt_group) +break ; + insn->cfi = first_insn->cfi; + } +}If I am reading this and previous patch correctly...
Quoted 2 lines
The function would copy cfi only to "orig" alternative (its
insn->altsis non-empty,orig_insn->alt_groupdiffers fromnew_insn->alt_group), right?
Yes.
Quoted 2 lines
Would it make sense to do the same for "new" alternative, because of the invariant? It seems to me it is not processed anywhere that way.
No.
Quoted 2 lines
Am I missing something? Whenever I try to read all this alternatives handling in objtool, I get lost pretty soon.
We only care about the ORC covering the original range, because that is the range we execute code from. The memory where we store the alternative instructions (.altinstruction section) is never executed, that is, RIP should never point there, so we don't need ORC data covering it.
Re: [PATCH v2 02/14] objtool: Fix ORC vs alternatives
Quoted 38 lines · Peter Zijlstra
Quoted 27 lines · Miroslav Benes
Quoted 13 lines · Peter Zijlstra
/*
+ * Alternatives should not contain any ORC entries, this in turn means they
+ * should not contain any CFI ops, which implies all instructions should have
+ * the same same CFI state.
+ *
+ * It is possible to constuct alternatives that have unreachable holes that go
+ * unreported (because they're NOPs), such holes would result inCFI_UNDEFINED
+ * states which then results in ORC entries, which we just said we didn't want.
+ *
+ * Avoid them by copying the CFI entry of the first instruction into the whole
+ * alternative.
+ */tools/objtool/check.c +1
-0+static void fill_alternative_cfi (struct objtool_file *file,struct instruction *insn)tools/objtool/check.c static bool is_branch_to_alternative(str · line 2206
Quoted 10 lines
tools/objtool/check.c +10
-0+{ +struct instruction *first_insn = insn; +int alt_group = insn->alt_group; + +sec_for_each_insn_continue (file, insn) { +if (insn->alt_group != alt_group) +break ; + insn->cfi = first_insn->cfi; + } +}If I am reading this and previous patch correctly...
Quoted 2 lines
The function would copy cfi only to "orig" alternative (its
insn->altsis non-empty,orig_insn->alt_groupdiffers fromnew_insn->alt_group), right?Yes.
Quoted 2 lines
Would it make sense to do the same for "new" alternative, because of the invariant? It seems to me it is not processed anywhere that way.
No.
Quoted 8 lines
Quoted 2 lines
Am I missing something? Whenever I try to read all this alternatives handling in objtool, I get lost pretty soon.
We only care about the ORC covering the original range, because that is the range we execute code from. The memory where we store the alternative instructions (.altinstruction section) is never executed, that is, RIP should never point there, so we don't need ORC data covering it.
Aha, that's what I didn't realize (again). Note to myself (for the hundredth time): alternatives are not branches.
Thanks
Miroslav
[tip: objtool/core] objtool: Fix ORC vs alternatives
In reply to Peter ZijlstraThe following commit has been merged into the objtool/core branch of tip:
The following commit has been merged into the objtool/core branch of tip:
Commit-ID: 7117f16bf460ef8cd132e6e80c989677397b4868 Gitweb: https://git.kernel.org/tip/7117f16bf460ef8cd132e6e80c989677397b4868 Author: Peter Zijlstra <[email protected]> AuthorDate: Tue, 28 Apr 2020 19:37:01 +02:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Thu, 30 Apr 2020 20:14:31 +02:00
objtool: Fix ORC vs alternatives
Jann reported that (for instance) entry_64.o:general_protection has very odd ORC data:
0000000000000f40 <general_protection>:
#######sp:sp+8 bp:(und) type:iret end:0
f40: 90 nop
#######sp:(und) bp:(und) type:call end:0
f41: 90 nop
f42: 90 nop
#######sp:sp+8 bp:(und) type:iret end:0
f43: e8 a8 01 00 00 callq 10f0 <error_entry>
#######sp:sp+0 bp:(und) type:regs end:0
f48: f6 84 24 88 00 00 00 testb $0x3,0x88(%rsp)
f4f: 03
f50: 74 00 je f52 <general_protection+0x12>
f52: 48 89 e7 mov %rsp,%rdi
f55: 48 8b 74 24 78 mov 0x78(%rsp),%rsi
f5a: 48 c7 44 24 78 ff ff movq $0xffffffffffffffff,0x78(%rsp)
f61: ff ff
f63: e8 00 00 00 00 callq f68 <general_protection+0x28>
f68: e9 73 02 00 00 jmpq 11e0 <error_exit> #######sp:(und) bp:(und) type:call end:0
f6d: 0f 1f 00 nopl (%rax)
Note the entry at 0xf41. Josh found this was the result of commit:
764eef4b109a ("objtool: Rewrite alt->skip_orig")
Due to the early return in validate_branch() we no longer set insn->cfi of the original instruction stream (the NOPs at 0xf41 and 0xf42) and we'll end up with the above weirdness.
In other discussions we realized alternatives should be ORC invariant; that is, due to there being only a single ORC table, it must be valid for all alternatives. The easiest way to ensure this is to not allow any stack modifications in alternatives.
When we enforce this latter observation, we get the property that the whole alternative must have the same CFI, which we can employ to fix the former report.
--- tools/objtool/Documentation/stack-validation.txt | 7 +++- tools/objtool/check.c | 34 ++++++++++++++- 2 files changed, 40 insertions(+), 1 deletion(-)
tools/objtool/Documentation/stack-validation.txt +7 -0
@@ -315,6 +315,13 @@ they mean, and suggestions for how to fix them. function tracing inserts additional calls, which is not obvious from the sources). +10. file.o: warning: func()+0x5c: alternative modifies stack + + This means that an alternative includes instructions that modify the + stack. The problem is that there is only one ORC unwind table, this means + that the ORC unwind entries must be valid for each of the alternatives. + The easiest way to enforce this is to ensure alternatives do not contain + any ORC entries, which in turn implies the above constraint. If the error doesn't seem to make sense, it could be a bug in objtool. Feel free to ask the objtool maintainer for help.
tools/objtool/check.c +33 -1
@@ -1983,6 +1983,11 @@ static int handle_insn_ops(struct instruction *insn, struct insn_state *state)list_for_each_entry (op, &insn->stack_ops, list) {int res; +if (insn->alt_group) { +WARN_FUNC ("alternative modifies stack" , insn->sec, insn->offset); +return -1 ; + } + res =update_cfi_state (insn, &state->cfi, op);if (res)return res;
@@ -2150,6 +2155,30 @@ static int validate_return(struct symbol *func, struct instruction *insn, struct }/* +* Alternatives should not contain any ORC entries, this in turn means they +* should not contain any CFI ops, which implies all instructions should have +* the same same CFI state. +* +* It is possible to constuct alternatives that have unreachable holes that go +* unreported (because they're NOPs), such holes would result in CFI_UNDEFINED +* states which then results in ORC entries, which we just said we didn't want. +* +* Avoid them by copying the CFI entry of the first instruction into the whole +* alternative. +*/ +static void fill_alternative_cfi (struct objtool_file *file,struct instruction *insn) +{ +struct instruction *first_insn = insn; +int alt_group = insn->alt_group; + +sec_for_each_insn_continue (file, insn) { +if (insn->alt_group != alt_group) +break ; + insn->cfi = first_insn->cfi; + } +} + +/* * Follow the branch starting at the given instruction, and recursively follow * any other branches (jumps). Meanwhile, track the frame pointer state at * each instruction and validate all the rules described in
@@ -2200,7 +2229,7 @@ static int validate_branch(struct objtool_file *file, struct symbol *func, insn->visited |= visited; -if (!insn->ignore_alts) { +if (!insn->ignore_alts && !list_empty (&insn->alts)) {bool skip_orig = false;list_for_each_entry (alt, &insn->alts, list) {
@@ -2215,6 +2244,9 @@ static int validate_branch(struct objtool_file *file, struct symbol *func, } } +if (insn->alt_group) +fill_alternative_cfi (file, insn); +if (skip_orig)return 0 ; }
Peter Zijlstra
maintainerPATCH v2 3/14 x86,smap: Fix smap_{save,restore}() alternatives
In reply to Peter ZijlstraAs reported by objtool:
lib/ubsan.o: warning: objtool: .altinstr_replacement+0x0: alternative modifies stack lib/ubsan.o: warning: objtool: .altinstr_replacement+0x7: alternative modifies stack
the smap_{save,restore}() alternatives violate (the newly enforced) rule on stack invariance. That is, due to there only being a single ORC table it must be valid to any alternative. These alternatives violate this with the direct result that unwinds will not be correct in between these calls.
[ In specific, since we force SMAP on for objtool, running on !SMAP hardware will observe a different stack-layout and the ORC unwinder will stumble. ]
So rewrite the functions to unconditionally save/restore the flags, which gives an invariant stack layout irrespective of the SMAP state.
--- arch/x86/include/asm/smap.h | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)
arch/x86/include/asm/smap.h +7 -4
@@ -57,16 +57,19 @@ static __always_inline unsigned long sma {unsigned long flags; - asm volatile (ALTERNATIVE("", "pushf; pop %0; " __ASM_CLAC, - X86_FEATURE_SMAP) - : "=rm" (flags) : : "memory", "cc"); + asmvolatile ("# smap_save\n\t" +"pushf; pop %0" + :"=rm" (flags) : :"memory" ); + +clac ();return flags; } static __always_inline void smap_restore(unsigned long flags) { - asm volatile (ALTERNATIVE("", "push %0; popf", X86_FEATURE_SMAP) + asmvolatile ("# smap_restore\n\t" +"push %0; popf" : :"g" (flags) :"memory" ,"cc" ); }
Re: [PATCH v2 03/14] x86,smap: Fix smap_{save,restore}() alternatives
Quoted 39 lines · Peter Zijlstra
As reported by objtool:
lib/ubsan.o: warning: objtool: .altinstr_replacement+0x0: alternative modifies stacklib/ubsan.o: warning: objtool: .altinstr_replacement+0x7: alternative modifies stackthe smap_{save,restore}() alternatives violate (the newly enforced) rule on stack invariance. That is, due to there only being a single ORC table it must be valid to any alternative. These alternatives violate this with the direct result that unwinds will not be correct in between these calls.
[ In specific, since we force SMAP on for objtool, running on !SMAP hardware will observe a different stack-layout and the ORC unwinder will stumble. ]
So rewrite the functions to unconditionally save/restore the flags, which gives an invariant stack layout irrespective of the SMAP state.
Signed-off-by Peter Zijlstra (Intel) <[email protected]>--- arch/x86/include/asm/smap.h | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)arch/x86/include/asm/smap.h +5
-3@@ -57,16 +57,19 @@ static __always_inline unsigned long sma {unsigned long flags; - asm volatile (ALTERNATIVE("", "pushf; pop %0; " __ASM_CLAC, - X86_FEATURE_SMAP) - : "=rm" (flags) : : "memory", "cc"); + asmvolatile ("# smap_save\n\t" +"pushf; pop %0" + :"=rm" (flags) : :"memory" ); + +clac ();
arch/x86/include/asm/smap.h static __always_inline unsigned long sma · line 74
Quoted 10 lines
arch/x86/include/asm/smap.h +2
-1return flags; } static __always_inline void smap_restore(unsigned long flags) { - asm volatile (ALTERNATIVE("", "push %0; popf", X86_FEATURE_SMAP) + asmvolatile ("# smap_restore\n\t" +"push %0; popf" : :"g" (flags) :"memory" ,"cc" ); }
POPF is an expensive instruction that should be avoided if possible. A better solution would be to have the alternative jump over the push/pop when SMAP is disabled.
--
Brian Gerst
Peter Zijlstra
maintainerRe: [PATCH v2 03/14] x86,smap: Fix smap_{save,restore}() alternatives
Quoted 43 lines · Brian Gerst
Quoted 42 lines · Peter Zijlstra
As reported by objtool:
lib/ubsan.o: warning: objtool: .altinstr_replacement+0x0: alternative modifies stacklib/ubsan.o: warning: objtool: .altinstr_replacement+0x7: alternative modifies stackthe smap_{save,restore}() alternatives violate (the newly enforced) rule on stack invariance. That is, due to there only being a single ORC table it must be valid to any alternative. These alternatives violate this with the direct result that unwinds will not be correct in between these calls.
[ In specific, since we force SMAP on for objtool, running on !SMAP hardware will observe a different stack-layout and the ORC unwinder will stumble. ]
So rewrite the functions to unconditionally save/restore the flags, which gives an invariant stack layout irrespective of the SMAP state.
Signed-off-by Peter Zijlstra (Intel) <[email protected]>--- arch/x86/include/asm/smap.h | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)arch/x86/include/asm/smap.h +5
-3@@ -57,16 +57,19 @@ static __always_inline unsigned long sma {unsigned long flags; - asm volatile (ALTERNATIVE("", "pushf; pop %0; " __ASM_CLAC, - X86_FEATURE_SMAP) - : "=rm" (flags) : : "memory", "cc"); + asmvolatile ("# smap_save\n\t" +"pushf; pop %0" + :"=rm" (flags) : :"memory" ); + +clac ();return flags; }
Quoted 11 lines
arch/x86/include/asm/smap.h static __always_inline unsigned long sma · line 74
Quoted 7 lines
arch/x86/include/asm/smap.h +2
-1static __always_inline void smap_restore(unsigned long flags) { - asm volatile (ALTERNATIVE("", "push %0; popf", X86_FEATURE_SMAP) + asmvolatile ("# smap_restore\n\t" +"push %0; popf" : :"g" (flags) :"memory" ,"cc" ); }POPF is an expensive instruction that should be avoided if possible. A better solution would be to have the alternative jump over the push/pop when SMAP is disabled.
Yeah. I think I had that, but then confused myself again. I don't think it matters much if you look at where it's used though.
Still, let me try the jmp thing again..
Peter Zijlstra
maintainerRe: [PATCH v2 03/14] x86,smap: Fix smap_{save,restore}() alternatives
Quoted 8 lines · Peter Zijlstra
Quoted 3 lines
POPF is an expensive instruction that should be avoided if possible. A better solution would be to have the alternative jump over the push/pop when SMAP is disabled.
Yeah. I think I had that, but then confused myself again. I don't think it matters much if you look at where it's used though.
Still, let me try the jmp thing again..
Here goes..
---
Subject: x86,smap: Fix smap_{save,restore}() alternatives
From: Peter Zijlstra <[email protected]>
Date: Tue Apr 28 19:57:59 CEST 2020
As reported by objtool:
lib/ubsan.o: warning: objtool: .altinstr_replacement+0x0: alternative modifies stack lib/ubsan.o: warning: objtool: .altinstr_replacement+0x7: alternative modifies stack
the smap_{save,restore}() alternatives violate (the newly enforced) rule on stack invariance. That is, due to there only being a single ORC table it must be valid to any alternative. These alternatives violate this with the direct result that unwinds will not be correct when it hits between the PUSH and POP instructions.
Rewrite the functions to only have a conditional jump.
--- arch/x86/include/asm/smap.h | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-)
arch/x86/include/asm/smap.h +8 -3
@@ -57,8 +57,10 @@ static __always_inline unsigned long sma {unsigned long flags; - asm volatile (ALTERNATIVE("", "pushf; pop %0; " __ASM_CLAC, - X86_FEATURE_SMAP) + asmvolatile ("# smap_save\n\t" + ALTERNATIVE("jmp 1f", "", X86_FEATURE_SMAP) + "pushf; pop %0; " __ASM_CLAC "\n\t" + "1:" : "=rm" (flags) : : "memory", "cc"); return flags;
@@ -66,7 +68,10 @@ static __always_inline unsigned long sma static __always_inline void smap_restore(unsigned long flags) { - asm volatile (ALTERNATIVE("", "push %0; popf", X86_FEATURE_SMAP) + asmvolatile ("# smap_restore\n\t" + ALTERNATIVE("jmp 1f", "", X86_FEATURE_SMAP) + "push %0; popf\n\t" + "1:" : : "g" (flags) : "memory", "cc"); }
Re: [PATCH v2 03/14] x86,smap: Fix smap_{save,restore}() alternatives
Quoted 53 lines · Peter Zijlstra
Quoted 8 lines · Peter Zijlstra
Quoted 3 lines
POPF is an expensive instruction that should be avoided if possible. A better solution would be to have the alternative jump over the push/pop when SMAP is disabled.
Yeah. I think I had that, but then confused myself again. I don't think it matters much if you look at where it's used though.
Still, let me try the jmp thing again..
Here goes..
---
Subject: x86,smap: Fix smap_{save,restore}() alternatives
From: Peter Zijlstra <[email protected]>
Date: Tue Apr 28 19:57:59 CEST 2020As reported by objtool:
lib/ubsan.o: warning: objtool: .altinstr_replacement+0x0: alternative modifies stacklib/ubsan.o: warning: objtool: .altinstr_replacement+0x7: alternative modifies stackthe smap_{save,restore}() alternatives violate (the newly enforced) rule on stack invariance. That is, due to there only being a single ORC table it must be valid to any alternative. These alternatives violate this with the direct result that unwinds will not be correct when it hits between the PUSH and POP instructions.
Rewrite the functions to only have a conditional jump.
Signed-off-by Peter Zijlstra (Intel) <[email protected]>--- arch/x86/include/asm/smap.h | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-)arch/x86/include/asm/smap.h +4
-2@@ -57,8 +57,10 @@ static __always_inline unsigned long sma {unsigned long flags; - asm volatile (ALTERNATIVE("", "pushf; pop %0; " __ASM_CLAC, - X86_FEATURE_SMAP) + asmvolatile ("# smap_save\n\t" + ALTERNATIVE("jmp 1f", "", X86_FEATURE_SMAP) + "pushf; pop %0; " __ASM_CLAC "\n\t" + "1:" : "=rm" (flags) : : "memory", "cc"); return flags;@@ -66,7 +68,10 @@ static __always_inline unsigned long sma
arch/x86/include/asm/smap.h static __always_inline unsigned long sma · line 77
Quoted 10 lines
arch/x86/include/asm/smap.h +4
-1static __always_inline void smap_restore(unsigned long flags) { - asm volatile (ALTERNATIVE("", "push %0; popf", X86_FEATURE_SMAP) + asmvolatile ("# smap_restore\n\t" + ALTERNATIVE("jmp 1f", "", X86_FEATURE_SMAP) + "push %0; popf\n\t" + "1:" : : "g" (flags) : "memory", "cc"); }
Looks good. Alternatively, you could use static_cpu_has(X86_FEATURE_SMAP).
--
Brian Gerst
[tip: objtool/core] x86,smap: Fix smap_{save,restore}() alternatives
In reply to Peter ZijlstraThe following commit has been merged into the objtool/core branch of tip:
The following commit has been merged into the objtool/core branch of tip:
Commit-ID: 1ff865e343c2b59469d7e41d370a980a3f972c71 Gitweb: https://git.kernel.org/tip/1ff865e343c2b59469d7e41d370a980a3f972c71 Author: Peter Zijlstra <[email protected]> AuthorDate: Tue, 28 Apr 2020 19:57:59 +02:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Thu, 30 Apr 2020 20:14:31 +02:00
x86,smap: Fix smap_{save,restore}() alternatives
As reported by objtool:
lib/ubsan.o: warning: objtool: .altinstr_replacement+0x0: alternative modifies stack lib/ubsan.o: warning: objtool: .altinstr_replacement+0x7: alternative modifies stack
the smap_{save,restore}() alternatives violate (the newly enforced) rule on stack invariance. That is, due to there only being a single ORC table it must be valid to any alternative. These alternatives violate this with the direct result that unwinds will not be correct when it hits between the PUSH and POP instructions.
Rewrite the functions to only have a conditional jump.
--- arch/x86/include/asm/smap.h | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-)
arch/x86/include/asm/smap.h +8 -3
@@ -57,8 +57,10 @@ static __always_inline unsigned long smap_save(void) {unsigned long flags; - asm volatile (ALTERNATIVE("", "pushf; pop %0; " __ASM_CLAC, - X86_FEATURE_SMAP) + asmvolatile ("# smap_save\n\t" + ALTERNATIVE("jmp 1f", "", X86_FEATURE_SMAP) + "pushf; pop %0; " __ASM_CLAC "\n\t" + "1:" : "=rm" (flags) : : "memory", "cc"); return flags;
@@ -66,7 +68,10 @@ static __always_inline unsigned long smap_save(void) static __always_inline void smap_restore(unsigned long flags) { - asm volatile (ALTERNATIVE("", "push %0; popf", X86_FEATURE_SMAP) + asmvolatile ("# smap_restore\n\t" + ALTERNATIVE("jmp 1f", "", X86_FEATURE_SMAP) + "push %0; popf\n\t" + "1:" : : "g" (flags) : "memory", "cc"); }
Peter Zijlstra
maintainerPATCH v2 4/14 objtool: is_fentry_call() crashes if call has no destination
In reply to Peter ZijlstraFrom: Alexandre Chartre <[email protected]>
Fix is_fentry_call() so that it works if a call has no destination set (call_dest). This needs to be done in order to support intra- function calls.
--- tools/objtool/check.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
tools/objtool/check.c +1 -1
@@ -1490,7 +1490,7 @@ static int decode_sections(struct objtoostatic bool is_fentry_call (struct instruction *insn) { -if (insn->type ==INSN_CALL && +if (insn->type ==INSN_CALL && insn->call_dest && insn->call_dest->type ==STT_NOTYPE && !strcmp (insn->call_dest->name,"__fentry__" ))return true;
Peter Zijlstra
maintainerPATCH v2 5/14 objtool: UNWIND_HINT_RET_OFFSET should not check registers
In reply to Peter ZijlstraFrom: Alexandre Chartre <[email protected]>
UNWIND_HINT_RET_OFFSET will adjust a modified stack. However if a callee-saved register was pushed on the stack then the stack frame will still appear modified. So stop checking registers when UNWIND_HINT_RET_OFFSET is used.
--- tools/objtool/check.c | 8 ++++++++ 1 file changed, 8 insertions(+)
tools/objtool/check.c +8 -0
@@ -1513,6 +1513,14 @@ static bool has_modified_stack_frame(strif (cfi->stack_size != initial_func_cfi.cfa.offset + ret_offset)return true; +/* +* If there is a ret offset hint then don't check registers +* because a callee-saved register might have been pushed on +* the stack. +*/ +if (ret_offset) +return false; +for (i =0 ; i <CFI_NUM_REGS ; i++) {if (cfi->regs[i].base != initial_func_cfi.regs[i].base || cfi->regs[i].offset != initial_func_cfi.regs[i].offset)
Peter Zijlstra
maintainerPATCH v2 6/14 objtool: Rework allocating stack_ops on decode
In reply to Peter ZijlstraWrap each stack_op in a macro that allocates and adds it to the list. This simplifies trying to figure out what to do with the pre-allocated stack_op at the end.
--- tools/objtool/arch/x86/decode.c | 251 +++++++++++++++++++++++----------------- 1 file changed, 147 insertions(+), 104 deletions(-)
tools/objtool/arch/x86/decode.c +147 -104
@@ -77,6 +77,11 @@ unsigned long arch_jump_destination(strureturn insn->offset + insn->len + insn->immediate; } +#define ADD_OP (op) \ + if (!(op = calloc(1, sizeof(*op)))) \ + return -1; \ + else for (list_add_tail(&op->list, ops_list); op; op = NULL) + int arch_decode_instruction(const struct elf *elf, const struct section *sec, unsigned long offset, unsigned int maxlen, unsigned int *len, enum insn_type *type,
@@ -88,7 +93,7 @@ int arch_decode_instruction(const structunsigned char op1, op2, rex =0 , rex_b =0 , rex_r =0 , rex_w =0 , rex_x =0 , modrm =0 , modrm_mod =0 , modrm_rm =0 , modrm_reg =0 , sib =0 ; -struct stack_op *op; +struct stack_op *op =NULL ; x86_64 =is_x86_64 (elf);if (x86_64 ==-1 )
@@ -129,10 +134,6 @@ int arch_decode_instruction(const structif (insn.sib.nbytes) sib = insn.sib.bytes[0 ]; - op =calloc (1 ,sizeof (*op)); -if (!op) -return -1 ; -switch (op1) {case 0x1 :
@@ -141,10 +142,12 @@ int arch_decode_instruction(const struct/* add/sub reg, %rsp */ *type =INSN_STACK ; - op->src.type =OP_SRC_ADD ; - op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +ADD_OP (op) { + op->src.type =OP_SRC_ADD ; + op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + } }break ;
@@ -152,9 +155,11 @@ int arch_decode_instruction(const struct/* push reg */ *type =INSN_STACK ; - op->src.type =OP_SRC_REG ; - op->src.reg = op_to_cfi_reg[op1 &0x7 ][rex_b]; - op->dest.type =OP_DEST_PUSH ; +ADD_OP (op) { + op->src.type =OP_SRC_REG ; + op->src.reg = op_to_cfi_reg[op1 &0x7 ][rex_b]; + op->dest.type =OP_DEST_PUSH ; + }break ;
@@ -162,9 +167,11 @@ int arch_decode_instruction(const struct/* pop reg */ *type =INSN_STACK ; - op->src.type =OP_SRC_POP ; - op->dest.type =OP_DEST_REG ; - op->dest.reg = op_to_cfi_reg[op1 &0x7 ][rex_b]; +ADD_OP (op) { + op->src.type =OP_SRC_POP ; + op->dest.type =OP_DEST_REG ; + op->dest.reg = op_to_cfi_reg[op1 &0x7 ][rex_b]; + }break ;
@@ -172,8 +179,10 @@ int arch_decode_instruction(const structcase 0x6a :/* push immediate */ *type =INSN_STACK ; - op->src.type =OP_SRC_CONST ; - op->dest.type =OP_DEST_PUSH ; + ADD_OP(op) { + op->src.type =OP_SRC_CONST ; + op->dest.type =OP_DEST_PUSH ; + }break ; case 0x70 ... 0x7f:
@@ -188,11 +197,13 @@ int arch_decode_instruction(const structif (modrm ==0xe4 ) {/* and imm, %rsp */ *type =INSN_STACK ; - op->src.type =OP_SRC_AND ; - op->src.reg =CFI_SP ; - op->src.offset = insn.immediate.value; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +ADD_OP (op) { + op->src.type =OP_SRC_AND ; + op->src.reg =CFI_SP ; + op->src.offset = insn.immediate.value; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + }break ; }
@@ -205,11 +216,13 @@ int arch_decode_instruction(const struct/* add/sub imm, %rsp */ *type =INSN_STACK ; - op->src.type =OP_SRC_ADD ; - op->src.reg =CFI_SP ; - op->src.offset = insn.immediate.value * sign; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +ADD_OP (op) { + op->src.type =OP_SRC_ADD ; + op->src.reg =CFI_SP ; + op->src.offset = insn.immediate.value * sign; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + }break ;case 0x89 :
@@ -217,10 +230,12 @@ int arch_decode_instruction(const struct/* mov %rsp, reg */ *type =INSN_STACK ; - op->src.type =OP_SRC_REG ; - op->src.reg =CFI_SP ; - op->dest.type =OP_DEST_REG ; - op->dest.reg = op_to_cfi_reg[modrm_rm][rex_b]; +ADD_OP (op) { + op->src.type =OP_SRC_REG ; + op->src.reg =CFI_SP ; + op->dest.type =OP_DEST_REG ; + op->dest.reg = op_to_cfi_reg[modrm_rm][rex_b]; + }break ; }
@@ -228,10 +243,12 @@ int arch_decode_instruction(const struct/* mov reg, %rsp */ *type =INSN_STACK ; - op->src.type =OP_SRC_REG ; - op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +ADD_OP (op) { + op->src.type =OP_SRC_REG ; + op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + }break ; }
@@ -242,21 +259,25 @@ int arch_decode_instruction(const struct/* mov reg, disp(%rbp) */ *type =INSN_STACK ; - op->src.type =OP_SRC_REG ; - op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; - op->dest.type =OP_DEST_REG_INDIRECT ; - op->dest.reg =CFI_BP ; - op->dest.offset = insn.displacement.value; +ADD_OP (op) { + op->src.type =OP_SRC_REG ; + op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; + op->dest.type =OP_DEST_REG_INDIRECT ; + op->dest.reg =CFI_BP ; + op->dest.offset = insn.displacement.value; + } }else if (rex_w && !rex_b && modrm_rm ==4 && sib ==0x24 ) {/* mov reg, disp(%rsp) */ *type =INSN_STACK ; - op->src.type =OP_SRC_REG ; - op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; - op->dest.type =OP_DEST_REG_INDIRECT ; - op->dest.reg =CFI_SP ; - op->dest.offset = insn.displacement.value; +ADD_OP (op) { + op->src.type =OP_SRC_REG ; + op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; + op->dest.type =OP_DEST_REG_INDIRECT ; + op->dest.reg =CFI_SP ; + op->dest.offset = insn.displacement.value; + } }break ;
@@ -266,22 +287,26 @@ int arch_decode_instruction(const struct/* mov disp(%rbp), reg */ *type =INSN_STACK ; - op->src.type =OP_SRC_REG_INDIRECT ; - op->src.reg =CFI_BP ; - op->src.offset = insn.displacement.value; - op->dest.type =OP_DEST_REG ; - op->dest.reg = op_to_cfi_reg[modrm_reg][rex_r]; +ADD_OP (op) { + op->src.type =OP_SRC_REG_INDIRECT ; + op->src.reg =CFI_BP ; + op->src.offset = insn.displacement.value; + op->dest.type =OP_DEST_REG ; + op->dest.reg = op_to_cfi_reg[modrm_reg][rex_r]; + } }else if (rex_w && !rex_b && sib ==0x24 && modrm_mod !=3 && modrm_rm ==4 ) {/* mov disp(%rsp), reg */ *type =INSN_STACK ; - op->src.type =OP_SRC_REG_INDIRECT ; - op->src.reg =CFI_SP ; - op->src.offset = insn.displacement.value; - op->dest.type =OP_DEST_REG ; - op->dest.reg = op_to_cfi_reg[modrm_reg][rex_r]; +ADD_OP (op) { + op->src.type =OP_SRC_REG_INDIRECT ; + op->src.reg =CFI_SP ; + op->src.offset = insn.displacement.value; + op->dest.type =OP_DEST_REG ; + op->dest.reg = op_to_cfi_reg[modrm_reg][rex_r]; + } }break ;
@@ -290,27 +315,31 @@ int arch_decode_instruction(const structif (sib ==0x24 && rex_w && !rex_b && !rex_x) { *type =INSN_STACK ; -if (!insn.displacement.value) { -/* lea (%rsp), reg */ - op->src.type =OP_SRC_REG ; - }else { -/* lea disp(%rsp), reg */ - op->src.type =OP_SRC_ADD ; - op->src.offset = insn.displacement.value; +ADD_OP (op) { +if (!insn.displacement.value) { +/* lea (%rsp), reg */ + op->src.type =OP_SRC_REG ; + }else { +/* lea disp(%rsp), reg */ + op->src.type =OP_SRC_ADD ; + op->src.offset = insn.displacement.value; + } + op->src.reg =CFI_SP ; + op->dest.type =OP_DEST_REG ; + op->dest.reg = op_to_cfi_reg[modrm_reg][rex_r]; } - op->src.reg =CFI_SP ; - op->dest.type =OP_DEST_REG ; - op->dest.reg = op_to_cfi_reg[modrm_reg][rex_r]; }else if (rex ==0x48 && modrm ==0x65 ) {/* lea disp(%rbp), %rsp */ *type =INSN_STACK ; - op->src.type =OP_SRC_ADD ; - op->src.reg =CFI_BP ; - op->src.offset = insn.displacement.value; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +ADD_OP (op) { + op->src.type =OP_SRC_ADD ; + op->src.reg =CFI_BP ; + op->src.offset = insn.displacement.value; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + } }else if (rex ==0x49 && modrm ==0x62 && insn.displacement.value ==-8 ) {
@@ -322,11 +351,13 @@ int arch_decode_instruction(const struct* stack realignment. */ *type =INSN_STACK ; - op->src.type =OP_SRC_ADD ; - op->src.reg =CFI_R10 ; - op->src.offset =-8 ; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +ADD_OP (op) { + op->src.type =OP_SRC_ADD ; + op->src.reg =CFI_R10 ; + op->src.offset =-8 ; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + } }else if (rex ==0x49 && modrm ==0x65 && insn.displacement.value ==-16 ) {
@@ -338,11 +369,13 @@ int arch_decode_instruction(const struct* stack realignment. */ *type =INSN_STACK ; - op->src.type =OP_SRC_ADD ; - op->src.reg =CFI_R13 ; - op->src.offset =-16 ; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +ADD_OP (op) { + op->src.type =OP_SRC_ADD ; + op->src.reg =CFI_R13 ; + op->src.offset =-16 ; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + } }break ;
@@ -350,8 +383,10 @@ int arch_decode_instruction(const structcase 0x8f :/* pop to mem */ *type =INSN_STACK ; - op->src.type =OP_SRC_POP ; - op->dest.type =OP_DEST_MEM ; + ADD_OP(op) { + op->src.type =OP_SRC_POP ; + op->dest.type =OP_DEST_MEM ; + }break ;case 0x90 :
@@ -361,15 +396,19 @@ int arch_decode_instruction(const structcase 0x9c :/* pushf */ *type =INSN_STACK ; - op->src.type =OP_SRC_CONST ; - op->dest.type =OP_DEST_PUSHF ; + ADD_OP(op) { + op->src.type =OP_SRC_CONST ; + op->dest.type =OP_DEST_PUSHF ; + }break ;case 0x9d :/* popf */ *type =INSN_STACK ; - op->src.type =OP_SRC_POPF ; - op->dest.type =OP_DEST_MEM ; + ADD_OP(op) { + op->src.type =OP_SRC_POPF ; + op->dest.type =OP_DEST_MEM ; + }break ;case 0x0f :
@@ -405,15 +444,19 @@ int arch_decode_instruction(const struct/* push fs/gs */ *type =INSN_STACK ; - op->src.type =OP_SRC_CONST ; - op->dest.type =OP_DEST_PUSH ; +ADD_OP (op) { + op->src.type =OP_SRC_CONST ; + op->dest.type =OP_DEST_PUSH ; + } }else if (op2 ==0xa1 || op2 ==0xa9 ) {/* pop fs/gs */ *type =INSN_STACK ; - op->src.type =OP_SRC_POP ; - op->dest.type =OP_DEST_MEM ; +ADD_OP (op) { + op->src.type =OP_SRC_POP ; + op->dest.type =OP_DEST_MEM ; + } }break ;
@@ -427,7 +470,8 @@ int arch_decode_instruction(const struct* pop bp */ *type =INSN_STACK ; - op->dest.type =OP_DEST_LEAVE ; +ADD_OP (op) + op->dest.type = OP_DEST_LEAVE;break ;
@@ -449,12 +493,14 @@ int arch_decode_instruction(const structcase 0xcf :/* iret */ *type =INSN_EXCEPTION_RETURN ; -/* add $40, %rsp */ - op->src.type =OP_SRC_ADD ; - op->src.reg =CFI_SP ; - op->src.offset =5 *8 ; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; + ADD_OP(op) { +/* add $40, %rsp */ + op->src.type =OP_SRC_ADD ; + op->src.reg =CFI_SP ; + op->src.offset =5 *8 ; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + }break ;case 0xca :/* retf */
@@ -492,8 +538,10 @@ int arch_decode_instruction(const struct/* push from mem */ *type =INSN_STACK ; - op->src.type =OP_SRC_CONST ; - op->dest.type =OP_DEST_PUSH ; +ADD_OP (op) { + op->src.type =OP_SRC_CONST ; + op->dest.type =OP_DEST_PUSH ; + } }break ;
@@ -504,11 +552,6 @@ int arch_decode_instruction(const struct *immediate = insn.immediate.nbytes ? insn.immediate.value :0 ; -if (*type ==INSN_STACK || *type ==INSN_EXCEPTION_RETURN ) -list_add_tail (&op->list, ops_list); -else -free (op); -return 0 ; }
[tip: objtool/core] objtool: Rework allocating stack_ops on decode
The following commit has been merged into the objtool/core branch of tip:
The following commit has been merged into the objtool/core branch of tip:
Commit-ID: 7d989fcadd6e225a61d6490dd15bdbdfc8a53d5c Gitweb: https://git.kernel.org/tip/7d989fcadd6e225a61d6490dd15bdbdfc8a53d5c Author: Peter Zijlstra <[email protected]> AuthorDate: Thu, 23 Apr 2020 13:22:10 +02:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Thu, 30 Apr 2020 20:14:32 +02:00
objtool: Rework allocating stack_ops on decode
Wrap each stack_op in a macro that allocates and adds it to the list. This simplifies trying to figure out what to do with the pre-allocated stack_op at the end.
--- tools/objtool/arch/x86/decode.c | 251 ++++++++++++++++++------------- 1 file changed, 147 insertions(+), 104 deletions(-)
tools/objtool/arch/x86/decode.c +147 -104
@@ -77,6 +77,11 @@ unsigned long arch_jump_destination(struct instruction *insn)return insn->offset + insn->len + insn->immediate; } +#define ADD_OP (op) \ + if (!(op = calloc(1, sizeof(*op)))) \ + return -1; \ + else for (list_add_tail(&op->list, ops_list); op; op = NULL) + int arch_decode_instruction(const struct elf *elf, const struct section *sec, unsigned long offset, unsigned int maxlen, unsigned int *len, enum insn_type *type,
@@ -88,7 +93,7 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,unsigned char op1, op2, rex =0 , rex_b =0 , rex_r =0 , rex_w =0 , rex_x =0 , modrm =0 , modrm_mod =0 , modrm_rm =0 , modrm_reg =0 , sib =0 ; -struct stack_op *op; +struct stack_op *op =NULL ; x86_64 =is_x86_64 (elf);if (x86_64 ==-1 )
@@ -129,10 +134,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,if (insn.sib.nbytes) sib = insn.sib.bytes[0 ]; - op =calloc (1 ,sizeof (*op)); -if (!op) -return -1 ; -switch (op1) {case 0x1 :
@@ -141,10 +142,12 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,/* add/sub reg, %rsp */ *type =INSN_STACK ; - op->src.type =OP_SRC_ADD ; - op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +ADD_OP (op) { + op->src.type =OP_SRC_ADD ; + op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + } }break ;
@@ -152,9 +155,11 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,/* push reg */ *type =INSN_STACK ; - op->src.type =OP_SRC_REG ; - op->src.reg = op_to_cfi_reg[op1 &0x7 ][rex_b]; - op->dest.type =OP_DEST_PUSH ; +ADD_OP (op) { + op->src.type =OP_SRC_REG ; + op->src.reg = op_to_cfi_reg[op1 &0x7 ][rex_b]; + op->dest.type =OP_DEST_PUSH ; + }break ;
@@ -162,9 +167,11 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,/* pop reg */ *type =INSN_STACK ; - op->src.type =OP_SRC_POP ; - op->dest.type =OP_DEST_REG ; - op->dest.reg = op_to_cfi_reg[op1 &0x7 ][rex_b]; +ADD_OP (op) { + op->src.type =OP_SRC_POP ; + op->dest.type =OP_DEST_REG ; + op->dest.reg = op_to_cfi_reg[op1 &0x7 ][rex_b]; + }break ;
@@ -172,8 +179,10 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,case 0x6a :/* push immediate */ *type =INSN_STACK ; - op->src.type =OP_SRC_CONST ; - op->dest.type =OP_DEST_PUSH ; + ADD_OP(op) { + op->src.type =OP_SRC_CONST ; + op->dest.type =OP_DEST_PUSH ; + }break ; case 0x70 ... 0x7f:
@@ -188,11 +197,13 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,if (modrm ==0xe4 ) {/* and imm, %rsp */ *type =INSN_STACK ; - op->src.type =OP_SRC_AND ; - op->src.reg =CFI_SP ; - op->src.offset = insn.immediate.value; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +ADD_OP (op) { + op->src.type =OP_SRC_AND ; + op->src.reg =CFI_SP ; + op->src.offset = insn.immediate.value; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + }break ; }
@@ -205,11 +216,13 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,/* add/sub imm, %rsp */ *type =INSN_STACK ; - op->src.type =OP_SRC_ADD ; - op->src.reg =CFI_SP ; - op->src.offset = insn.immediate.value * sign; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +ADD_OP (op) { + op->src.type =OP_SRC_ADD ; + op->src.reg =CFI_SP ; + op->src.offset = insn.immediate.value * sign; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + }break ;case 0x89 :
@@ -217,10 +230,12 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,/* mov %rsp, reg */ *type =INSN_STACK ; - op->src.type =OP_SRC_REG ; - op->src.reg =CFI_SP ; - op->dest.type =OP_DEST_REG ; - op->dest.reg = op_to_cfi_reg[modrm_rm][rex_b]; +ADD_OP (op) { + op->src.type =OP_SRC_REG ; + op->src.reg =CFI_SP ; + op->dest.type =OP_DEST_REG ; + op->dest.reg = op_to_cfi_reg[modrm_rm][rex_b]; + }break ; }
@@ -228,10 +243,12 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,/* mov reg, %rsp */ *type =INSN_STACK ; - op->src.type =OP_SRC_REG ; - op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +ADD_OP (op) { + op->src.type =OP_SRC_REG ; + op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + }break ; }
@@ -242,21 +259,25 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,/* mov reg, disp(%rbp) */ *type =INSN_STACK ; - op->src.type =OP_SRC_REG ; - op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; - op->dest.type =OP_DEST_REG_INDIRECT ; - op->dest.reg =CFI_BP ; - op->dest.offset = insn.displacement.value; +ADD_OP (op) { + op->src.type =OP_SRC_REG ; + op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; + op->dest.type =OP_DEST_REG_INDIRECT ; + op->dest.reg =CFI_BP ; + op->dest.offset = insn.displacement.value; + } }else if (rex_w && !rex_b && modrm_rm ==4 && sib ==0x24 ) {/* mov reg, disp(%rsp) */ *type =INSN_STACK ; - op->src.type =OP_SRC_REG ; - op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; - op->dest.type =OP_DEST_REG_INDIRECT ; - op->dest.reg =CFI_SP ; - op->dest.offset = insn.displacement.value; +ADD_OP (op) { + op->src.type =OP_SRC_REG ; + op->src.reg = op_to_cfi_reg[modrm_reg][rex_r]; + op->dest.type =OP_DEST_REG_INDIRECT ; + op->dest.reg =CFI_SP ; + op->dest.offset = insn.displacement.value; + } }break ;
@@ -266,22 +287,26 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,/* mov disp(%rbp), reg */ *type =INSN_STACK ; - op->src.type =OP_SRC_REG_INDIRECT ; - op->src.reg =CFI_BP ; - op->src.offset = insn.displacement.value; - op->dest.type =OP_DEST_REG ; - op->dest.reg = op_to_cfi_reg[modrm_reg][rex_r]; +ADD_OP (op) { + op->src.type =OP_SRC_REG_INDIRECT ; + op->src.reg =CFI_BP ; + op->src.offset = insn.displacement.value; + op->dest.type =OP_DEST_REG ; + op->dest.reg = op_to_cfi_reg[modrm_reg][rex_r]; + } }else if (rex_w && !rex_b && sib ==0x24 && modrm_mod !=3 && modrm_rm ==4 ) {/* mov disp(%rsp), reg */ *type =INSN_STACK ; - op->src.type =OP_SRC_REG_INDIRECT ; - op->src.reg =CFI_SP ; - op->src.offset = insn.displacement.value; - op->dest.type =OP_DEST_REG ; - op->dest.reg = op_to_cfi_reg[modrm_reg][rex_r]; +ADD_OP (op) { + op->src.type =OP_SRC_REG_INDIRECT ; + op->src.reg =CFI_SP ; + op->src.offset = insn.displacement.value; + op->dest.type =OP_DEST_REG ; + op->dest.reg = op_to_cfi_reg[modrm_reg][rex_r]; + } }break ;
@@ -290,27 +315,31 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,if (sib ==0x24 && rex_w && !rex_b && !rex_x) { *type =INSN_STACK ; -if (!insn.displacement.value) { -/* lea (%rsp), reg */ - op->src.type =OP_SRC_REG ; - }else { -/* lea disp(%rsp), reg */ - op->src.type =OP_SRC_ADD ; - op->src.offset = insn.displacement.value; +ADD_OP (op) { +if (!insn.displacement.value) { +/* lea (%rsp), reg */ + op->src.type =OP_SRC_REG ; + }else { +/* lea disp(%rsp), reg */ + op->src.type =OP_SRC_ADD ; + op->src.offset = insn.displacement.value; + } + op->src.reg =CFI_SP ; + op->dest.type =OP_DEST_REG ; + op->dest.reg = op_to_cfi_reg[modrm_reg][rex_r]; } - op->src.reg =CFI_SP ; - op->dest.type =OP_DEST_REG ; - op->dest.reg = op_to_cfi_reg[modrm_reg][rex_r]; }else if (rex ==0x48 && modrm ==0x65 ) {/* lea disp(%rbp), %rsp */ *type =INSN_STACK ; - op->src.type =OP_SRC_ADD ; - op->src.reg =CFI_BP ; - op->src.offset = insn.displacement.value; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +ADD_OP (op) { + op->src.type =OP_SRC_ADD ; + op->src.reg =CFI_BP ; + op->src.offset = insn.displacement.value; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + } }else if (rex ==0x49 && modrm ==0x62 && insn.displacement.value ==-8 ) {
@@ -322,11 +351,13 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,* stack realignment. */ *type =INSN_STACK ; - op->src.type =OP_SRC_ADD ; - op->src.reg =CFI_R10 ; - op->src.offset =-8 ; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +ADD_OP (op) { + op->src.type =OP_SRC_ADD ; + op->src.reg =CFI_R10 ; + op->src.offset =-8 ; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + } }else if (rex ==0x49 && modrm ==0x65 && insn.displacement.value ==-16 ) {
@@ -338,11 +369,13 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,* stack realignment. */ *type =INSN_STACK ; - op->src.type =OP_SRC_ADD ; - op->src.reg =CFI_R13 ; - op->src.offset =-16 ; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +ADD_OP (op) { + op->src.type =OP_SRC_ADD ; + op->src.reg =CFI_R13 ; + op->src.offset =-16 ; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + } }break ;
@@ -350,8 +383,10 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,case 0x8f :/* pop to mem */ *type =INSN_STACK ; - op->src.type =OP_SRC_POP ; - op->dest.type =OP_DEST_MEM ; + ADD_OP(op) { + op->src.type =OP_SRC_POP ; + op->dest.type =OP_DEST_MEM ; + }break ;case 0x90 :
@@ -361,15 +396,19 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,case 0x9c :/* pushf */ *type =INSN_STACK ; - op->src.type =OP_SRC_CONST ; - op->dest.type =OP_DEST_PUSHF ; + ADD_OP(op) { + op->src.type =OP_SRC_CONST ; + op->dest.type =OP_DEST_PUSHF ; + }break ;case 0x9d :/* popf */ *type =INSN_STACK ; - op->src.type =OP_SRC_POPF ; - op->dest.type =OP_DEST_MEM ; + ADD_OP(op) { + op->src.type =OP_SRC_POPF ; + op->dest.type =OP_DEST_MEM ; + }break ;case 0x0f :
@@ -405,15 +444,19 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,/* push fs/gs */ *type =INSN_STACK ; - op->src.type =OP_SRC_CONST ; - op->dest.type =OP_DEST_PUSH ; +ADD_OP (op) { + op->src.type =OP_SRC_CONST ; + op->dest.type =OP_DEST_PUSH ; + } }else if (op2 ==0xa1 || op2 ==0xa9 ) {/* pop fs/gs */ *type =INSN_STACK ; - op->src.type =OP_SRC_POP ; - op->dest.type =OP_DEST_MEM ; +ADD_OP (op) { + op->src.type =OP_SRC_POP ; + op->dest.type =OP_DEST_MEM ; + } }break ;
@@ -427,7 +470,8 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,* pop bp */ *type =INSN_STACK ; - op->dest.type =OP_DEST_LEAVE ; +ADD_OP (op) + op->dest.type = OP_DEST_LEAVE;break ;
@@ -449,12 +493,14 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,case 0xcf :/* iret */ *type =INSN_EXCEPTION_RETURN ; -/* add $40, %rsp */ - op->src.type =OP_SRC_ADD ; - op->src.reg =CFI_SP ; - op->src.offset =5 *8 ; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; + ADD_OP(op) { +/* add $40, %rsp */ + op->src.type =OP_SRC_ADD ; + op->src.reg =CFI_SP ; + op->src.offset =5 *8 ; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + }break ;case 0xca :/* retf */
@@ -492,8 +538,10 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,/* push from mem */ *type =INSN_STACK ; - op->src.type =OP_SRC_CONST ; - op->dest.type =OP_DEST_PUSH ; +ADD_OP (op) { + op->src.type =OP_SRC_CONST ; + op->dest.type =OP_DEST_PUSH ; + } }break ;
@@ -504,11 +552,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec, *immediate = insn.immediate.nbytes ? insn.immediate.value :0 ; -if (*type ==INSN_STACK || *type ==INSN_EXCEPTION_RETURN ) -list_add_tail (&op->list, ops_list); -else -free (op); -return 0 ; }
Peter Zijlstra
maintainerPATCH v2 7/14 objtool: Make handle_insn_ops() unconditional
In reply to Peter ZijlstraNow that every instruction has a list of stack_ops; we can trivially distinquish those instructions that do not have stack_ops, their list is empty.
This means we can now call handle_insn_ops() unconditionally.
--- tools/objtool/check.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
tools/objtool/check.c +3 -5
@@ -2247,6 +2247,9 @@ static int validate_branch(struct objtooreturn 0 ; } +if (handle_insn_ops (insn, &state)) +return 1 ; +switch (insn->type) {case INSN_RETURN :
@@ -2306,9 +2309,6 @@ static int validate_branch(struct objtoobreak ;case INSN_EXCEPTION_RETURN : -if (handle_insn_ops (insn, &state)) -return 1 ; -/* * This handles x86's sync_core() case, where we use an * IRET to self. All 'normal' IRET instructions are in
@@ -2328,8 +2328,6 @@ static int validate_branch(struct objtooreturn 0 ;case INSN_STACK : -if (handle_insn_ops (insn, &state)) -return 1 ;break ;case INSN_STAC :
[tip: objtool/core] objtool: Make handle_insn_ops() unconditional
The following commit has been merged into the objtool/core branch of tip:
The following commit has been merged into the objtool/core branch of tip:
Commit-ID: 60041bcd8f5ab560dabf44dc384f58bbeb5a6a30 Gitweb: https://git.kernel.org/tip/60041bcd8f5ab560dabf44dc384f58bbeb5a6a30 Author: Peter Zijlstra <[email protected]> AuthorDate: Fri, 24 Apr 2020 16:16:41 +02:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Thu, 30 Apr 2020 20:14:32 +02:00
objtool: Make handle_insn_ops() unconditional
Now that every instruction has a list of stack_ops; we can trivially distinquish those instructions that do not have stack_ops, their list is empty.
This means we can now call handle_insn_ops() unconditionally.
--- tools/objtool/check.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
tools/objtool/check.c +3 -5
@@ -2259,6 +2259,9 @@ static int validate_branch(struct objtool_file *file, struct symbol *func,return 0 ; } +if (handle_insn_ops (insn, &state)) +return 1 ; +switch (insn->type) {case INSN_RETURN :
@@ -2318,9 +2321,6 @@ static int validate_branch(struct objtool_file *file, struct symbol *func,break ;case INSN_EXCEPTION_RETURN : -if (handle_insn_ops (insn, &state)) -return 1 ; -/* * This handles x86's sync_core() case, where we use an * IRET to self. All 'normal' IRET instructions are in
@@ -2340,8 +2340,6 @@ static int validate_branch(struct objtool_file *file, struct symbol *func,return 0 ;case INSN_STACK : -if (handle_insn_ops (insn, &state)) -return 1 ;break ;case INSN_STAC :
Peter Zijlstra
maintainerRe: [tip: objtool/core] objtool: Make handle_insn_ops() unconditional
Quoted 5 lines · On Fri, May 01, 2020 at 06:22:21PM -0000, tip-bot2 for Peter Zijlstra wrote:
tools/objtool/check.c +0
-0
tools/objtool/check.c static int validate_branch(struct objtool_file *file, struct symbol *func, · line 2267
Quoted 9 lines
tools/objtool/check.c +3
-0@@ -2259,6 +2259,9 @@ static int validate_branch(struct objtool_file *file, struct symbol *func,return 0 ; } +if (handle_insn_ops (insn, &state)) +return 1 ; +switch (insn->type) {case INSN_RETURN :
Fun question; when an instruction has both a hint and ops, who should win? I'm currently in that situation and I'd like the hint to win, but is that 'right' ?
Peter Zijlstra
maintainerPATCH v2 8/14 objtool: Remove INSN_STACK
In reply to Peter ZijlstraWith the unconditional use of handle_insn_ops(), INSN_STACK has lost its purpose. Remove it.
--- tools/objtool/arch.h | 1 - tools/objtool/arch/x86/decode.c | 23 ----------------------- tools/objtool/check.c | 3 --- 3 files changed, 27 deletions(-)
tools/objtool/arch.h +0 -1
@@ -21,7 +21,6 @@ enum insn_type {INSN_RETURN ,INSN_EXCEPTION_RETURN ,INSN_CONTEXT_SWITCH , -INSN_STACK ,INSN_BUG ,INSN_NOP , INSN_STAC,
tools/objtool/arch/x86/decode.c +0 -23
@@ -141,7 +141,6 @@ int arch_decode_instruction(const structif (rex_w && !rex_b && modrm_mod ==3 && modrm_rm ==4 ) {/* add/sub reg, %rsp */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_ADD ; op->src.reg = op_to_cfi_reg[modrm_reg][rex_r];
@@ -154,7 +153,6 @@ int arch_decode_instruction(const struct case 0x50 ... 0x57:/* push reg */ - *type =INSN_STACK ; ADD_OP(op) { op->src.type =OP_SRC_REG ; op->src.reg = op_to_cfi_reg[op1 &0x7 ][rex_b];
@@ -166,7 +164,6 @@ int arch_decode_instruction(const struct case 0x58 ... 0x5f:/* pop reg */ - *type =INSN_STACK ; ADD_OP(op) { op->src.type =OP_SRC_POP ; op->dest.type =OP_DEST_REG ;
@@ -178,7 +175,6 @@ int arch_decode_instruction(const structcase 0x68 :case 0x6a :/* push immediate */ - *type =INSN_STACK ; ADD_OP(op) { op->src.type =OP_SRC_CONST ; op->dest.type =OP_DEST_PUSH ;
@@ -196,7 +192,6 @@ int arch_decode_instruction(const structif (modrm ==0xe4 ) {/* and imm, %rsp */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_AND ; op->src.reg =CFI_SP ;
@@ -215,7 +210,6 @@ int arch_decode_instruction(const structbreak ;/* add/sub imm, %rsp */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_ADD ; op->src.reg =CFI_SP ;
@@ -229,7 +223,6 @@ int arch_decode_instruction(const structif (rex_w && !rex_r && modrm_mod ==3 && modrm_reg ==4 ) {/* mov %rsp, reg */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_REG ; op->src.reg =CFI_SP ;
@@ -242,7 +235,6 @@ int arch_decode_instruction(const structif (rex_w && !rex_b && modrm_mod ==3 && modrm_rm ==4 ) {/* mov reg, %rsp */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_REG ; op->src.reg = op_to_cfi_reg[modrm_reg][rex_r];
@@ -258,7 +250,6 @@ int arch_decode_instruction(const struct (modrm_mod == 1 || modrm_mod == 2) && modrm_rm == 5) {/* mov reg, disp(%rbp) */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_REG ; op->src.reg = op_to_cfi_reg[modrm_reg][rex_r];
@@ -270,7 +261,6 @@ int arch_decode_instruction(const struct }else if (rex_w && !rex_b && modrm_rm ==4 && sib ==0x24 ) {/* mov reg, disp(%rsp) */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_REG ; op->src.reg = op_to_cfi_reg[modrm_reg][rex_r];
@@ -286,7 +276,6 @@ int arch_decode_instruction(const structif (rex_w && !rex_b && modrm_mod ==1 && modrm_rm ==5 ) {/* mov disp(%rbp), reg */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_REG_INDIRECT ; op->src.reg =CFI_BP ;
@@ -299,7 +288,6 @@ int arch_decode_instruction(const struct modrm_mod != 3 && modrm_rm == 4) {/* mov disp(%rsp), reg */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_REG_INDIRECT ; op->src.reg =CFI_SP ;
@@ -314,7 +302,6 @@ int arch_decode_instruction(const structcase 0x8d :if (sib ==0x24 && rex_w && !rex_b && !rex_x) { - *type =INSN_STACK ;ADD_OP (op) {if (!insn.displacement.value) {/* lea (%rsp), reg */
@@ -332,7 +319,6 @@ int arch_decode_instruction(const struct }else if (rex ==0x48 && modrm ==0x65 ) {/* lea disp(%rbp), %rsp */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_ADD ; op->src.reg =CFI_BP ;
@@ -350,7 +336,6 @@ int arch_decode_instruction(const struct* Restoring rsp back to its original value after a * stack realignment. */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_ADD ; op->src.reg =CFI_R10 ;
@@ -368,7 +353,6 @@ int arch_decode_instruction(const struct* Restoring rsp back to its original value after a * stack realignment. */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_ADD ; op->src.reg =CFI_R13 ;
@@ -382,7 +366,6 @@ int arch_decode_instruction(const structcase 0x8f :/* pop to mem */ - *type =INSN_STACK ; ADD_OP(op) { op->src.type =OP_SRC_POP ; op->dest.type =OP_DEST_MEM ;
@@ -395,7 +378,6 @@ int arch_decode_instruction(const structcase 0x9c :/* pushf */ - *type =INSN_STACK ; ADD_OP(op) { op->src.type =OP_SRC_CONST ; op->dest.type =OP_DEST_PUSHF ;
@@ -404,7 +386,6 @@ int arch_decode_instruction(const structcase 0x9d :/* popf */ - *type =INSN_STACK ; ADD_OP(op) { op->src.type =OP_SRC_POPF ; op->dest.type =OP_DEST_MEM ;
@@ -443,7 +424,6 @@ int arch_decode_instruction(const struct }else if (op2 ==0xa0 || op2 ==0xa8 ) {/* push fs/gs */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_CONST ; op->dest.type =OP_DEST_PUSH ;
@@ -452,7 +432,6 @@ int arch_decode_instruction(const struct }else if (op2 ==0xa1 || op2 ==0xa9 ) {/* pop fs/gs */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_POP ; op->dest.type =OP_DEST_MEM ;
@@ -469,7 +448,6 @@ int arch_decode_instruction(const struct* mov bp, sp * pop bp */ - *type =INSN_STACK ;ADD_OP (op) op->dest.type = OP_DEST_LEAVE;
@@ -537,7 +515,6 @@ int arch_decode_instruction(const structelse if (modrm_reg ==6 ) {/* push from mem */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_CONST ; op->dest.type =OP_DEST_PUSH ;
tools/objtool/check.c +0 -3
@@ -2327,9 +2327,6 @@ static int validate_branch(struct objtoo }return 0 ; -case INSN_STACK : -break ; -case INSN_STAC :if (state.uaccess) {WARN_FUNC ("recursive UACCESS enable" , sec, insn->offset);
[tip: objtool/core] objtool: Remove INSN_STACK
The following commit has been merged into the objtool/core branch of tip:
The following commit has been merged into the objtool/core branch of tip:
Commit-ID: b09fb65e863733e192d4825a285b4b4998969ce0 Gitweb: https://git.kernel.org/tip/b09fb65e863733e192d4825a285b4b4998969ce0 Author: Peter Zijlstra <[email protected]> AuthorDate: Fri, 24 Apr 2020 16:18:58 +02:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Thu, 30 Apr 2020 20:14:33 +02:00
objtool: Remove INSN_STACK
With the unconditional use of handle_insn_ops(), INSN_STACK has lost its purpose. Remove it.
--- tools/objtool/arch.h | 1 - tools/objtool/arch/x86/decode.c | 23 ----------------------- tools/objtool/check.c | 3 --- 3 files changed, 27 deletions(-)
tools/objtool/arch.h +0 -1
@@ -21,7 +21,6 @@ enum insn_type {INSN_RETURN ,INSN_EXCEPTION_RETURN ,INSN_CONTEXT_SWITCH , -INSN_STACK ,INSN_BUG ,INSN_NOP , INSN_STAC,
tools/objtool/arch/x86/decode.c +0 -23
@@ -141,7 +141,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,if (rex_w && !rex_b && modrm_mod ==3 && modrm_rm ==4 ) {/* add/sub reg, %rsp */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_ADD ; op->src.reg = op_to_cfi_reg[modrm_reg][rex_r];
@@ -154,7 +153,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec, case 0x50 ... 0x57:/* push reg */ - *type =INSN_STACK ; ADD_OP(op) { op->src.type =OP_SRC_REG ; op->src.reg = op_to_cfi_reg[op1 &0x7 ][rex_b];
@@ -166,7 +164,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec, case 0x58 ... 0x5f:/* pop reg */ - *type =INSN_STACK ; ADD_OP(op) { op->src.type =OP_SRC_POP ; op->dest.type =OP_DEST_REG ;
@@ -178,7 +175,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,case 0x68 :case 0x6a :/* push immediate */ - *type =INSN_STACK ; ADD_OP(op) { op->src.type =OP_SRC_CONST ; op->dest.type =OP_DEST_PUSH ;
@@ -196,7 +192,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,if (modrm ==0xe4 ) {/* and imm, %rsp */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_AND ; op->src.reg =CFI_SP ;
@@ -215,7 +210,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,break ;/* add/sub imm, %rsp */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_ADD ; op->src.reg =CFI_SP ;
@@ -229,7 +223,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,if (rex_w && !rex_r && modrm_mod ==3 && modrm_reg ==4 ) {/* mov %rsp, reg */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_REG ; op->src.reg =CFI_SP ;
@@ -242,7 +235,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,if (rex_w && !rex_b && modrm_mod ==3 && modrm_rm ==4 ) {/* mov reg, %rsp */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_REG ; op->src.reg = op_to_cfi_reg[modrm_reg][rex_r];
@@ -258,7 +250,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec, (modrm_mod == 1 || modrm_mod == 2) && modrm_rm == 5) {/* mov reg, disp(%rbp) */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_REG ; op->src.reg = op_to_cfi_reg[modrm_reg][rex_r];
@@ -270,7 +261,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec, }else if (rex_w && !rex_b && modrm_rm ==4 && sib ==0x24 ) {/* mov reg, disp(%rsp) */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_REG ; op->src.reg = op_to_cfi_reg[modrm_reg][rex_r];
@@ -286,7 +276,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,if (rex_w && !rex_b && modrm_mod ==1 && modrm_rm ==5 ) {/* mov disp(%rbp), reg */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_REG_INDIRECT ; op->src.reg =CFI_BP ;
@@ -299,7 +288,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec, modrm_mod != 3 && modrm_rm == 4) {/* mov disp(%rsp), reg */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_REG_INDIRECT ; op->src.reg =CFI_SP ;
@@ -314,7 +302,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,case 0x8d :if (sib ==0x24 && rex_w && !rex_b && !rex_x) { - *type =INSN_STACK ;ADD_OP (op) {if (!insn.displacement.value) {/* lea (%rsp), reg */
@@ -332,7 +319,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec, }else if (rex ==0x48 && modrm ==0x65 ) {/* lea disp(%rbp), %rsp */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_ADD ; op->src.reg =CFI_BP ;
@@ -350,7 +336,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,* Restoring rsp back to its original value after a * stack realignment. */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_ADD ; op->src.reg =CFI_R10 ;
@@ -368,7 +353,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,* Restoring rsp back to its original value after a * stack realignment. */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_ADD ; op->src.reg =CFI_R13 ;
@@ -382,7 +366,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,case 0x8f :/* pop to mem */ - *type =INSN_STACK ; ADD_OP(op) { op->src.type =OP_SRC_POP ; op->dest.type =OP_DEST_MEM ;
@@ -395,7 +378,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,case 0x9c :/* pushf */ - *type =INSN_STACK ; ADD_OP(op) { op->src.type =OP_SRC_CONST ; op->dest.type =OP_DEST_PUSHF ;
@@ -404,7 +386,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,case 0x9d :/* popf */ - *type =INSN_STACK ; ADD_OP(op) { op->src.type =OP_SRC_POPF ; op->dest.type =OP_DEST_MEM ;
@@ -443,7 +424,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec, }else if (op2 ==0xa0 || op2 ==0xa8 ) {/* push fs/gs */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_CONST ; op->dest.type =OP_DEST_PUSH ;
@@ -452,7 +432,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec, }else if (op2 ==0xa1 || op2 ==0xa9 ) {/* pop fs/gs */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_POP ; op->dest.type =OP_DEST_MEM ;
@@ -469,7 +448,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,* mov bp, sp * pop bp */ - *type =INSN_STACK ;ADD_OP (op) op->dest.type = OP_DEST_LEAVE;
@@ -537,7 +515,6 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,else if (modrm_reg ==6 ) {/* push from mem */ - *type =INSN_STACK ;ADD_OP (op) { op->src.type =OP_SRC_CONST ; op->dest.type =OP_DEST_PUSH ;
tools/objtool/check.c +0 -3
@@ -2339,9 +2339,6 @@ static int validate_branch(struct objtool_file *file, struct symbol *func, }return 0 ; -case INSN_STACK : -break ; -case INSN_STAC :if (state.uaccess) {WARN_FUNC ("recursive UACCESS enable" , sec, insn->offset);
Peter Zijlstra
maintainerPATCH v2 9/14 objtool: Move the IRET hack into the arch decoder
In reply to Peter ZijlstraFrom: Miroslav Benes <[email protected]>
Quoting Julien:
"And the other suggestion is my other email was that you don't even need to add INSN_EXCEPTION_RETURN. You can keep IRET as INSN_CONTEXT_SWITCH by default and x86 decoder lookups the symbol conaining an iret. If it's a function symbol, it can just set the type to INSN_OTHER so that it caries on to the next instruction after having handled the stack_op."
--- tools/objtool/arch.h | 1 - tools/objtool/arch/x86/decode.c | 28 ++++++++++++++++++---------- tools/objtool/check.c | 11 ----------- tools/objtool/elf.c | 4 ++-- tools/objtool/elf.h | 2 +- 5 files changed, 21 insertions(+), 25 deletions(-)
tools/objtool/arch.h +0 -1
@@ -19,7 +19,6 @@ enum insn_type {INSN_CALL ,INSN_CALL_DYNAMIC ,INSN_RETURN , -INSN_EXCEPTION_RETURN ,INSN_CONTEXT_SWITCH ,INSN_BUG , INSN_NOP,
tools/objtool/arch/x86/decode.c +18 -10
@@ -94,6 +94,7 @@ int arch_decode_instruction(const struct rex_x =0 , modrm =0 , modrm_mod =0 , modrm_rm =0 , modrm_reg =0 , sib =0 ;struct stack_op *op =NULL ; +struct symbol *sym; x86_64 =is_x86_64 (elf);if (x86_64 ==-1 )
@@ -469,17 +470,24 @@ int arch_decode_instruction(const structbreak ;case 0xcf :/* iret */ - *type =INSN_EXCEPTION_RETURN ; - - ADD_OP(op) { -/* add $40, %rsp */ - op->src.type =OP_SRC_ADD ; - op->src.reg =CFI_SP ; - op->src.offset =5 *8 ; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +/* +* Handle sync_core(), which has an IRET to self. +* All other IRET are in STT_NONE entry code. +*/ + sym =find_symbol_containing (sec, offset); +if (sym && sym->type ==STT_FUNC ) { +ADD_OP (op) { +/* add $40, %rsp */ + op->src.type =OP_SRC_ADD ; + op->src.reg =CFI_SP ; + op->src.offset =5 *8 ; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + } +break ; } -break ; + +/* fallthrough */ case 0xca :/* retf */ case 0xcb :/* retf */
tools/objtool/check.c +0 -11
@@ -2308,17 +2308,6 @@ static int validate_branch(struct objtoobreak ; -case INSN_EXCEPTION_RETURN : -/* -* This handles x86's sync_core() case, where we use an -* IRET to self. All 'normal' IRET instructions are in -* STT_NOTYPE entry symbols. -*/ -if (func) -break ; - -return 0 ; -case INSN_CONTEXT_SWITCH :if (func && (!next_insn || !next_insn->hint)) { WARN_FUNC("unsupported instruction in callable function",
tools/objtool/elf.c +2 -2
@@ -61,7 +61,7 @@ static void rb_add(struct rb_root *tree,rb_insert_color (node, tree); } -static struct rb_node *rb_find_first (struct rb_root *tree,const void *key, +static struct rb_node *rb_find_first (const struct rb_root *tree,const void *key,int (*cmp)(const void *key,const struct rb_node *)) {struct rb_node *node = tree->rb_node;
@@ -189,7 +189,7 @@ struct symbol *find_func_by_offset(strucreturn NULL ; } -struct symbol *find_symbol_containing (struct section *sec,unsigned long offset) +struct symbol *find_symbol_containing (const struct section *sec,unsigned long offset) {struct rb_node *node;
tools/objtool/elf.h +1 -1
@@ -124,7 +124,7 @@ struct section *find_section_by_name(construct symbol *find_func_by_offset (struct section *sec,unsigned long offset);struct symbol *find_symbol_by_offset (struct section *sec,unsigned long offset);struct symbol *find_symbol_by_name (const struct elf *elf,const char *name); -struct symbol *find_symbol_containing (struct section *sec,unsigned long offset); +struct symbol *find_symbol_containing (const struct section *sec,unsigned long offset);struct rela *find_rela_by_dest (const struct elf *elf,struct section *sec,unsigned long offset);struct rela *find_rela_by_dest_range (const struct elf *elf,struct section *sec,unsigned long offset,unsigned int len);
[tip: objtool/core] objtool: Move the IRET hack into the arch decoder
The following commit has been merged into the objtool/core branch of tip:
The following commit has been merged into the objtool/core branch of tip:
Commit-ID: b490f45362002fef57996388e395efc974b013f4 Gitweb: https://git.kernel.org/tip/b490f45362002fef57996388e395efc974b013f4 Author: Miroslav Benes <[email protected]> AuthorDate: Fri, 24 Apr 2020 16:30:42 +02:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Thu, 30 Apr 2020 20:14:33 +02:00
objtool: Move the IRET hack into the arch decoder
Quoting Julien:
"And the other suggestion is my other email was that you don't even need to add INSN_EXCEPTION_RETURN. You can keep IRET as INSN_CONTEXT_SWITCH by default and x86 decoder lookups the symbol conaining an iret. If it's a function symbol, it can just set the type to INSN_OTHER so that it caries on to the next instruction after having handled the stack_op."
--- tools/objtool/arch.h | 1 - tools/objtool/arch/x86/decode.c | 28 ++++++++++++++++++---------- tools/objtool/check.c | 11 ----------- tools/objtool/elf.c | 4 ++-- tools/objtool/elf.h | 2 +- 5 files changed, 21 insertions(+), 25 deletions(-)
tools/objtool/arch.h +0 -1
@@ -19,7 +19,6 @@ enum insn_type {INSN_CALL ,INSN_CALL_DYNAMIC ,INSN_RETURN , -INSN_EXCEPTION_RETURN ,INSN_CONTEXT_SWITCH ,INSN_BUG , INSN_NOP,
tools/objtool/arch/x86/decode.c +18 -10
@@ -94,6 +94,7 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec, rex_x =0 , modrm =0 , modrm_mod =0 , modrm_rm =0 , modrm_reg =0 , sib =0 ;struct stack_op *op =NULL ; +struct symbol *sym; x86_64 =is_x86_64 (elf);if (x86_64 ==-1 )
@@ -469,17 +470,24 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec,break ;case 0xcf :/* iret */ - *type =INSN_EXCEPTION_RETURN ; - - ADD_OP(op) { -/* add $40, %rsp */ - op->src.type =OP_SRC_ADD ; - op->src.reg =CFI_SP ; - op->src.offset =5 *8 ; - op->dest.type =OP_DEST_REG ; - op->dest.reg =CFI_SP ; +/* +* Handle sync_core(), which has an IRET to self. +* All other IRET are in STT_NONE entry code. +*/ + sym =find_symbol_containing (sec, offset); +if (sym && sym->type ==STT_FUNC ) { +ADD_OP (op) { +/* add $40, %rsp */ + op->src.type =OP_SRC_ADD ; + op->src.reg =CFI_SP ; + op->src.offset =5 *8 ; + op->dest.type =OP_DEST_REG ; + op->dest.reg =CFI_SP ; + } +break ; } -break ; + +/* fallthrough */ case 0xca :/* retf */ case 0xcb :/* retf */
tools/objtool/check.c +0 -11
@@ -2320,17 +2320,6 @@ static int validate_branch(struct objtool_file *file, struct symbol *func,break ; -case INSN_EXCEPTION_RETURN : -/* -* This handles x86's sync_core() case, where we use an -* IRET to self. All 'normal' IRET instructions are in -* STT_NOTYPE entry symbols. -*/ -if (func) -break ; - -return 0 ; -case INSN_CONTEXT_SWITCH :if (func && (!next_insn || !next_insn->hint)) { WARN_FUNC("unsupported instruction in callable function",
tools/objtool/elf.c +2 -2
@@ -61,7 +61,7 @@ static void rb_add(struct rb_root *tree, struct rb_node *node,rb_insert_color (node, tree); } -static struct rb_node *rb_find_first (struct rb_root *tree,const void *key, +static struct rb_node *rb_find_first (const struct rb_root *tree,const void *key,int (*cmp)(const void *key,const struct rb_node *)) {struct rb_node *node = tree->rb_node;
@@ -189,7 +189,7 @@ struct symbol *find_func_by_offset(struct section *sec, unsigned long offset)return NULL ; } -struct symbol *find_symbol_containing (struct section *sec,unsigned long offset) +struct symbol *find_symbol_containing (const struct section *sec,unsigned long offset) {struct rb_node *node;
tools/objtool/elf.h +1 -1
@@ -124,7 +124,7 @@ struct section *find_section_by_name(const struct elf *elf, const char *name);struct symbol *find_func_by_offset (struct section *sec,unsigned long offset);struct symbol *find_symbol_by_offset (struct section *sec,unsigned long offset);struct symbol *find_symbol_by_name (const struct elf *elf,const char *name); -struct symbol *find_symbol_containing (struct section *sec,unsigned long offset); +struct symbol *find_symbol_containing (const struct section *sec,unsigned long offset);struct rela *find_rela_by_dest (const struct elf *elf,struct section *sec,unsigned long offset);struct rela *find_rela_by_dest_range (const struct elf *elf,struct section *sec,unsigned long offset,unsigned int len);
Peter Zijlstra
maintainerPATCH v2 10/14 objtool: Add support for intra-function calls
In reply to Peter ZijlstraFrom: Alexandre Chartre <[email protected]>
Change objtool to support intra-function calls. On x86, an intra-function call is represented in objtool as a push onto the stack (of the return address), and a jump to the destination address. That way the stack information is correctly updated and the call flow is still accurate.
--- include/linux/frame.h | 11 +++ tools/objtool/Documentation/stack-validation.txt | 8 ++ tools/objtool/arch/x86/decode.c | 8 ++ tools/objtool/check.c | 79 +++++++++++++++++++++-- 4 files changed, 102 insertions(+), 4 deletions(-)
include/linux/frame.h +11 -0
@@ -15,9 +15,20 @@ static void __used __section(.discard.func_stack_frame_non_standard) \ *__func_stack_frame_non_standard_##func = func +/* +* This macro indicates that the following intra-function call is valid. +* Any non-annotated intra-function call will cause objtool to issue a warning. + */ +#define ANNOTATE_INTRA_FUNCTION_CALL \ + 999: \ + .pushsection .discard.intra_function_calls; \ + .long 999b; \ + .popsection; +#else /* !CONFIG_STACK_VALIDATION */ #define STACK_FRAME_NON_STANDARD (func) +#define ANNOTATE_INTRA_FUNCTION_CALL #endif /* CONFIG_STACK_VALIDATION */
tools/objtool/Documentation/stack-validation.txt +8 -0
@@ -323,6 +323,14 @@ they mean, and suggestions for how to fi The easiest way to enforce this is to ensure alternative do not contain any ORC entries, which in turn implies the above constraint. +11. file.o: warning: unannotated intra-function call + + This warning means that a direct call is done to a destination which + is not at the beginning of a function. If this is a legit call, you + can remove this warning by putting the ANNOTATE_INTRA_FUNCTION_CALL + directive right before the call. + + If the error doesn't seem to make sense, it could be a bug in objtool. Feel free to ask the objtool maintainer for help.
tools/objtool/arch/x86/decode.c +8 -0
@@ -496,6 +496,14 @@ int arch_decode_instruction(const structcase 0xe8 : *type =INSN_CALL ; +/* +* For the impact on the stack, a CALL behaves like +* a PUSH of an immediate value (the return address). +*/ + ADD_OP(op) { + op->src.type =OP_SRC_CONST ; + op->dest.type =OP_DEST_PUSH ; + }break ;case 0xfc :
tools/objtool/check.c +75 -4
109 lines not on this page · raw message
Peter Zijlstra
maintainerPATCH v2 11/14 x86/speculation: Change FILL_RETURN_BUFFER to work with objtool
In reply to Peter ZijlstraChange FILL_RETURN_BUFFER so that objtool groks it and can generate correct ORC unwind information.
- Since ORC is alternative invariant; that is, all alternatives should have the same ORC entries, the __FILL_RETURN_BUFFER body can not be part of an alternative.
Therefore, move it out of the alternative and keep the alternative as a sort of jump_label around it.
- Use the ANNOTATE_INTRA_FUNCTION_CALL annotation to white-list these 'funny' call instructions to nowhere.
- Use UNWIND_HINT_EMPTY to 'fill' the speculation traps, otherwise objtool will consider them unreachable.
- Move the RSP adjustment into the loop, such that the loop has a deterministic stack layout.
--- arch/x86/include/asm/nospec-branch.h | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-)
arch/x86/include/asm/nospec-branch.h +10 -6
@@ -4,11 +4,13 @@#define _ASM_X86_NOSPEC_BRANCH_H_#include <linux/static_key.h> +#include <linux/frame.h> #include <asm/alternative.h> #include <asm/alternative-asm.h> #include <asm/cpufeatures.h> #include <asm/msr-index.h> +#include <asm/unwind_hints.h> /* * This should be used immediately before a retpoline alternative. It tells
@@ -46,21 +48,25 @@#define __FILL_RETURN_BUFFER (reg, nr, sp) \ mov $(nr/2), reg; \ 771: \ + ANNOTATE_INTRA_FUNCTION_CALL; \ call 772f; \ 773:/* speculation trap */ \ +UNWIND_HINT_EMPTY ; \ pause; \ lfence; \ jmp 773b; \ 772: \ +ANNOTATE_INTRA_FUNCTION_CALL ; \ call 774f; \ 775: /* speculation trap */ \ +UNWIND_HINT_EMPTY ; \ pause; \ lfence; \ jmp 775b; \ 774: \ + add $(BITS_PER_LONG/8) * 2, sp; \dec reg; \ - jnz 771b; \ - add $(BITS_PER_LONG/8) * nr, sp; + jnz 771b;#ifdef __ASSEMBLY__
@@ -137,10 +143,8 @@*/ .macro FILL_RETURN_BUFFER reg:req nr:req ftr:req#ifdef CONFIG_RETPOLINE -ANNOTATE_NOSPEC_ALTERNATIVE - ALTERNATIVE "jmp .Lskip_rsb_\@", \ - __stringify(__FILL_RETURN_BUFFER(\reg,\nr,%_ASM_SP)) \ - \ftr + ALTERNATIVE "jmp .Lskip_rsb_\@", "", \ftr + __FILL_RETURN_BUFFER(\reg,\nr,%_ASM_SP) .Lskip_rsb_\@: #endif .endm
[tip: objtool/core] x86/speculation: Change FILL_RETURN_BUFFER to work with objtool
The following commit has been merged into the objtool/core branch of tip:
The following commit has been merged into the objtool/core branch of tip:
Commit-ID: 089dd8e53126ebaf506e2dc0bf89d652c36bfc12 Gitweb: https://git.kernel.org/tip/089dd8e53126ebaf506e2dc0bf89d652c36bfc12 Author: Peter Zijlstra <[email protected]> AuthorDate: Tue, 14 Apr 2020 12:36:16 +02:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Thu, 30 Apr 2020 20:14:34 +02:00
x86/speculation: Change FILL_RETURN_BUFFER to work with objtool
Change FILL_RETURN_BUFFER so that objtool groks it and can generate correct ORC unwind information.
- Since ORC is alternative invariant; that is, all alternatives should have the same ORC entries, the __FILL_RETURN_BUFFER body can not be part of an alternative.
Therefore, move it out of the alternative and keep the alternative as a sort of jump_label around it.
- Use the ANNOTATE_INTRA_FUNCTION_CALL annotation to white-list these 'funny' call instructions to nowhere.
- Use UNWIND_HINT_EMPTY to 'fill' the speculation traps, otherwise objtool will consider them unreachable.
- Move the RSP adjustment into the loop, such that the loop has a deterministic stack layout.
--- arch/x86/include/asm/nospec-branch.h | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-)
arch/x86/include/asm/nospec-branch.h +10 -6
@@ -4,11 +4,13 @@#define _ASM_X86_NOSPEC_BRANCH_H_#include <linux/static_key.h> +#include <linux/frame.h> #include <asm/alternative.h> #include <asm/alternative-asm.h> #include <asm/cpufeatures.h> #include <asm/msr-index.h> +#include <asm/unwind_hints.h> /* * This should be used immediately before a retpoline alternative. It tells
@@ -46,21 +48,25 @@#define __FILL_RETURN_BUFFER (reg, nr, sp) \ mov $(nr/2), reg; \ 771: \ + ANNOTATE_INTRA_FUNCTION_CALL; \ call 772f; \ 773:/* speculation trap */ \ +UNWIND_HINT_EMPTY ; \ pause; \ lfence; \ jmp 773b; \ 772: \ +ANNOTATE_INTRA_FUNCTION_CALL ; \ call 774f; \ 775: /* speculation trap */ \ +UNWIND_HINT_EMPTY ; \ pause; \ lfence; \ jmp 775b; \ 774: \ + add $(BITS_PER_LONG/8) * 2, sp; \dec reg; \ - jnz 771b; \ - add $(BITS_PER_LONG/8) * nr, sp; + jnz 771b;#ifdef __ASSEMBLY__
@@ -137,10 +143,8 @@*/ .macro FILL_RETURN_BUFFER reg:req nr:req ftr:req#ifdef CONFIG_RETPOLINE -ANNOTATE_NOSPEC_ALTERNATIVE - ALTERNATIVE "jmp .Lskip_rsb_\@", \ - __stringify(__FILL_RETURN_BUFFER(\reg,\nr,%_ASM_SP)) \ - \ftr + ALTERNATIVE "jmp .Lskip_rsb_\@", "", \ftr + __FILL_RETURN_BUFFER(\reg,\nr,%_ASM_SP) .Lskip_rsb_\@: #endif .endm
Peter Zijlstra
maintainerPATCH v2 12/14 x86: Simplify retpoline declaration
In reply to Peter ZijlstraBecause of how KSYM works, we need one declaration per line. Seeing how we're going to be doubling the amount of retpoline symbols, simplify the machinery in order to avoid having to copy/paste even more.
--- arch/x86/include/asm/GEN-for-each-reg.h | 25 ++++++++++++++++++++++ arch/x86/include/asm/asm-prototypes.h | 28 +++++++------------------ arch/x86/lib/retpoline.S | 35 +++++++++++++------------------- 3 files changed, 48 insertions(+), 40 deletions(-)
arch/x86/include/asm/GEN-for-each-reg.h new file +25 -0
@@ -0,0 +1,25 @@ +#ifdef CONFIG_64BIT +GEN(rax) +GEN(rbx) +GEN(rcx) +GEN(rdx) +GEN(rsi) +GEN(rdi) +GEN(rbp) +GEN(r8) +GEN(r9) +GEN(r10) +GEN(r11) +GEN(r12) +GEN(r13) +GEN(r14) +GEN(r15) +#else +GEN(eax) +GEN(ebx) +GEN(ecx) +GEN(edx) +GEN(esi) +GEN(edi) +GEN(ebp) +#endif
arch/x86/include/asm/asm-prototypes.h +8 -20
@@ -17,24 +17,12 @@ extern void cmpxchg8b_emu(void);#endif #ifdef CONFIG_RETPOLINE -#ifdef CONFIG_X86_32 -#define INDIRECT_THUNK (reg) extern asmlinkage void __x86_indirect_thunk_e ## reg(void); -#else -#define INDIRECT_THUNK (reg) extern asmlinkage void __x86_indirect_thunk_r ## reg(void); -INDIRECT_THUNK(8) -INDIRECT_THUNK(9) -INDIRECT_THUNK(10) -INDIRECT_THUNK(11) -INDIRECT_THUNK(12) -INDIRECT_THUNK(13) -INDIRECT_THUNK(14) -INDIRECT_THUNK(15) -#endif -INDIRECT_THUNK(ax) -INDIRECT_THUNK(bx) -INDIRECT_THUNK(cx) -INDIRECT_THUNK(dx) -INDIRECT_THUNK(si) -INDIRECT_THUNK(di) -INDIRECT_THUNK(bp) + +#define DECL_INDIRECT_THUNK (reg) \ + extern asmlinkage void __x86_indirect_thunk_ ## reg (void); + +#undef GEN +#define GEN (reg) DECL_INDIRECT_THUNK(reg) +#include <asm/GEN-for-each-reg.h> +#endif /* CONFIG_RETPOLINE */
arch/x86/lib/retpoline.S +15 -20
@@ -24,25 +24,20 @@ SYM_FUNC_END(__x86_indirect_thunk_\reg) * only see one instance of "__x86_indirect_thunk_\reg" rather * than one per register with the correct names. So we do it * the simple and nasty way... + * + * Worse, you can only have a single EXPORT_SYMBOL per line, + * and CPP can't insert newlines, so we have to repeat everything + * at least twice. */ -#define __EXPORT_THUNK(sym) _ASM_NOKPROBE(sym); EXPORT_SYMBOL(sym) -#define EXPORT_THUNK(reg) __EXPORT_THUNK(__x86_indirect_thunk_ ## reg) -#define GENERATE_THUNK(reg) THUNK reg ; EXPORT_THUNK(reg) -GENERATE_THUNK(_ASM_AX) -GENERATE_THUNK(_ASM_BX) -GENERATE_THUNK(_ASM_CX) -GENERATE_THUNK(_ASM_DX) -GENERATE_THUNK(_ASM_SI) -GENERATE_THUNK(_ASM_DI) -GENERATE_THUNK(_ASM_BP) -#ifdef CONFIG_64BIT -GENERATE_THUNK(r8) -GENERATE_THUNK(r9) -GENERATE_THUNK(r10) -GENERATE_THUNK(r11) -GENERATE_THUNK(r12) -GENERATE_THUNK(r13) -GENERATE_THUNK(r14) -GENERATE_THUNK(r15) -#endif +#define __EXPORT_THUNK(sym) _ASM_NOKPROBE(sym); EXPORT_SYMBOL(sym) +#define EXPORT_THUNK(reg) __EXPORT_THUNK(__x86_indirect_thunk_ ## reg) + +#undef GEN +#define GEN(reg) THUNK reg +#include <asm/GEN-for-each-reg.h> + +#undef GEN +#define GEN(reg) EXPORT_THUNK(reg) +#include <asm/GEN-for-each-reg.h> +
[tip: objtool/core] x86: Simplify retpoline declaration
The following commit has been merged into the objtool/core branch of tip:
The following commit has been merged into the objtool/core branch of tip:
Commit-ID: ca3f0d80dd57c8828bfb5bc0bc79750ea7a1ba26 Gitweb: https://git.kernel.org/tip/ca3f0d80dd57c8828bfb5bc0bc79750ea7a1ba26 Author: Peter Zijlstra <[email protected]> AuthorDate: Wed, 22 Apr 2020 17:03:22 +02:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Thu, 30 Apr 2020 20:14:34 +02:00
x86: Simplify retpoline declaration
Because of how KSYM works, we need one declaration per line. Seeing how we're going to be doubling the amount of retpoline symbols, simplify the machinery in order to avoid having to copy/paste even more.
--- arch/x86/include/asm/GEN-for-each-reg.h | 25 ++++++++++++++++- arch/x86/include/asm/asm-prototypes.h | 28 +++++------------- arch/x86/lib/retpoline.S | 37 ++++++++++-------------- 3 files changed, 49 insertions(+), 41 deletions(-) create mode 100644 arch/x86/include/asm/GEN-for-each-reg.h
arch/x86/include/asm/GEN-for-each-reg.h new file +25 -0
@@ -0,0 +1,25 @@ +#ifdef CONFIG_64BIT +GEN(rax) +GEN(rbx) +GEN(rcx) +GEN(rdx) +GEN(rsi) +GEN(rdi) +GEN(rbp) +GEN(r8) +GEN(r9) +GEN(r10) +GEN(r11) +GEN(r12) +GEN(r13) +GEN(r14) +GEN(r15) +#else +GEN(eax) +GEN(ebx) +GEN(ecx) +GEN(edx) +GEN(esi) +GEN(edi) +GEN(ebp) +#endif
arch/x86/include/asm/asm-prototypes.h +8 -20
@@ -17,24 +17,12 @@ extern void cmpxchg8b_emu(void);#endif #ifdef CONFIG_RETPOLINE -#ifdef CONFIG_X86_32 -#define INDIRECT_THUNK (reg) extern asmlinkage void __x86_indirect_thunk_e ## reg(void); -#else -#define INDIRECT_THUNK (reg) extern asmlinkage void __x86_indirect_thunk_r ## reg(void); -INDIRECT_THUNK(8) -INDIRECT_THUNK(9) -INDIRECT_THUNK(10) -INDIRECT_THUNK(11) -INDIRECT_THUNK(12) -INDIRECT_THUNK(13) -INDIRECT_THUNK(14) -INDIRECT_THUNK(15) -#endif -INDIRECT_THUNK(ax) -INDIRECT_THUNK(bx) -INDIRECT_THUNK(cx) -INDIRECT_THUNK(dx) -INDIRECT_THUNK(si) -INDIRECT_THUNK(di) -INDIRECT_THUNK(bp) + +#define DECL_INDIRECT_THUNK (reg) \ + extern asmlinkage void __x86_indirect_thunk_ ## reg (void); + +#undef GEN +#define GEN (reg) DECL_INDIRECT_THUNK(reg) +#include <asm/GEN-for-each-reg.h> +#endif /* CONFIG_RETPOLINE */
arch/x86/lib/retpoline.S +16 -21
@@ -24,25 +24,20 @@ SYM_FUNC_END(__x86_indirect_thunk_\reg) * only see one instance of "__x86_indirect_thunk_\reg" rather * than one per register with the correct names. So we do it * the simple and nasty way... + * + * Worse, you can only have a single EXPORT_SYMBOL per line, + * and CPP can't insert newlines, so we have to repeat everything + * at least twice. */ -#define __EXPORT_THUNK(sym) _ASM_NOKPROBE(sym); EXPORT_SYMBOL(sym) -#define EXPORT_THUNK(reg) __EXPORT_THUNK(__x86_indirect_thunk_ ## reg) -#define GENERATE_THUNK(reg) THUNK reg ; EXPORT_THUNK(reg) - -GENERATE_THUNK(_ASM_AX) -GENERATE_THUNK(_ASM_BX) -GENERATE_THUNK(_ASM_CX) -GENERATE_THUNK(_ASM_DX) -GENERATE_THUNK(_ASM_SI) -GENERATE_THUNK(_ASM_DI) -GENERATE_THUNK(_ASM_BP) -#ifdef CONFIG_64BIT -GENERATE_THUNK(r8) -GENERATE_THUNK(r9) -GENERATE_THUNK(r10) -GENERATE_THUNK(r11) -GENERATE_THUNK(r12) -GENERATE_THUNK(r13) -GENERATE_THUNK(r14) -GENERATE_THUNK(r15) -#endif + +#define __EXPORT_THUNK(sym) _ASM_NOKPROBE(sym); EXPORT_SYMBOL(sym) +#define EXPORT_THUNK(reg) __EXPORT_THUNK(__x86_indirect_thunk_ ## reg) + +#undef GEN +#define GEN(reg) THUNK reg +#include <asm/GEN-for-each-reg.h> + +#undef GEN +#define GEN(reg) EXPORT_THUNK(reg) +#include <asm/GEN-for-each-reg.h> +
Peter Zijlstra
maintainerPATCH v2 13/14 x86: Change {JMP,CALL}_NOSPEC argument
In reply to Peter ZijlstraIn order to change the {JMP,CALL}_NOSPEC macros to call out-of-line versions of the retpoline magic, we need to remove the '%' from the argument, such that we can paste it onto symbol names.
--- arch/x86/crypto/aesni-intel_asm.S | 4 ++-- arch/x86/crypto/camellia-aesni-avx-asm_64.S | 2 +- arch/x86/crypto/camellia-aesni-avx2-asm_64.S | 2 +- arch/x86/crypto/crc32c-pcl-intel-asm_64.S | 26 +++++++++++++------------- arch/x86/entry/entry_32.S | 6 +++--- arch/x86/entry/entry_64.S | 2 +- arch/x86/include/asm/nospec-branch.h | 16 ++++++++-------- arch/x86/kernel/ftrace_32.S | 2 +- arch/x86/kernel/ftrace_64.S | 4 ++-- arch/x86/lib/checksum_32.S | 4 ++-- arch/x86/platform/efi/efi_stub_64.S | 2 +- 11 files changed, 35 insertions(+), 35 deletions(-)
arch/x86/crypto/aesni-intel_asm.S +2 -2
@@ -2758,7 +2758,7 @@ SYM_FUNC_START(aesni_xts_crypt8) pxor INC, STATE4 movdqu IV, 0x30(OUTP) - CALL_NOSPEC %r11 + CALL_NOSPEC r11 movdqu 0x00(OUTP), INC pxor INC, STATE1
@@ -2803,7 +2803,7 @@ SYM_FUNC_START(aesni_xts_crypt8) _aesni_gf128mul_x_ble() movups IV, (IVP) - CALL_NOSPEC %r11 + CALL_NOSPEC r11 movdqu 0x40(OUTP), INC pxor INC, STATE1
arch/x86/crypto/camellia-aesni-avx-asm_64.S +1 -1
@@ -1228,7 +1228,7 @@ SYM_FUNC_START_LOCAL(camellia_xts_crypt_ vpxor 14 * 16(%rax), %xmm15, %xmm14; vpxor 15 * 16(%rax), %xmm15, %xmm15; - CALL_NOSPEC %r9; + CALL_NOSPEC r9; addq $(16 * 16), %rsp;
arch/x86/crypto/camellia-aesni-avx2-asm_64.S +1 -1
@@ -1339,7 +1339,7 @@ SYM_FUNC_START_LOCAL(camellia_xts_crypt_ vpxor 14 * 32(%rax), %ymm15, %ymm14; vpxor 15 * 32(%rax), %ymm15, %ymm15; - CALL_NOSPEC %r9; + CALL_NOSPEC r9; addq $(16 * 32), %rsp;
arch/x86/crypto/crc32c-pcl-intel-asm_64.S +13 -13
@@ -75,7 +75,7 @@ .text SYM_FUNC_START(crc_pcl) -#define bufp %rdi +#define bufp rdi #define bufp_dw %edi #define bufp_w %di #define bufp_b %dil
@@ -105,9 +105,9 @@ SYM_FUNC_START(crc_pcl) ## 1) ALIGN: ################################################################ - mov bufp, bufptmp # rdi = *buf - neg bufp - and $7, bufp # calculate the unalignment amount of + mov %bufp, bufptmp # rdi = *buf + neg %bufp + and $7, %bufp # calculate the unalignment amount of # the address je proc_block # Skip if aligned
@@ -123,13 +123,13 @@ SYM_FUNC_START(crc_pcl) do_align: #### Calculate CRC of unaligned bytes of the buffer (if any) movq (bufptmp), tmp # load a quadward from the buffer - add bufp, bufptmp # align buffer pointer for quadword + add %bufp, bufptmp # align buffer pointer for quadword # processing - sub bufp, len # update buffer length + sub %bufp, len # update buffer length align_loop: crc32b %bl, crc_init_dw # compute crc32 of 1-byte shr $8, tmp # get next byte - dec bufp + dec %bufp jne align_loop proc_block:
@@ -169,10 +169,10 @@ SYM_FUNC_START(crc_pcl) xor crc2, crc2 ## branch into array - lea jump_table(%rip), bufp - movzxw (bufp, %rax, 2), len - lea crc_array(%rip), bufp - lea (bufp, len, 1), bufp + lea jump_table(%rip), %bufp + movzxw (%bufp, %rax, 2), len + lea crc_array(%rip), %bufp + lea (%bufp, len, 1), %bufp JMP_NOSPEC bufp ################################################################
@@ -218,9 +218,9 @@ LABEL crc_ %i ## 4) Combine three results: ################################################################ - lea (K_table-8)(%rip), bufp # first entry is for idx 1 + lea (K_table-8)(%rip), %bufp # first entry is for idx 1 shlq $3, %rax # rax *= 8 - pmovzxdq (bufp,%rax), %xmm0 # 2 consts: K1:K2 + pmovzxdq (%bufp,%rax), %xmm0 # 2 consts: K1:K2 leal (%eax,%eax,2), %eax # rax *= 3 (total *24) subq %rax, tmp # tmp -= rax*24
arch/x86/entry/entry_32.S +3 -3
@@ -816,7 +816,7 @@ SYM_CODE_START(ret_from_fork) /* kernel thread */ 1: movl %edi, %eax - CALL_NOSPEC %ebx + CALL_NOSPEC ebx /* * A kernel thread is allowed to return here after successfully * calling do_execve(). Exit to userspace to complete the execve()
@@ -1501,7 +1501,7 @@ SYM_CODE_START_LOCAL_NOALIGN(common_exce TRACE_IRQS_OFF movl %esp, %eax # pt_regs pointer - CALL_NOSPEC %edi + CALL_NOSPEC edi jmp ret_from_exception SYM_CODE_END(common_exception_read_cr2)
@@ -1522,7 +1522,7 @@ SYM_CODE_START_LOCAL_NOALIGN(common_exce TRACE_IRQS_OFF movl %esp, %eax # pt_regs pointer - CALL_NOSPEC %edi + CALL_NOSPEC edi jmp ret_from_exception SYM_CODE_END(common_exception)
arch/x86/entry/entry_64.S +1 -1
@@ -349,7 +349,7 @@ SYM_CODE_START(ret_from_fork) /* kernel thread */ UNWIND_HINT_EMPTY movq %r12, %rdi - CALL_NOSPEC %rbx + CALL_NOSPEC rbx /* * A kernel thread is allowed to return here after successfully * calling do_execve(). Exit to userspace to complete the execve()
arch/x86/include/asm/nospec-branch.h +8 -8
@@ -118,22 +118,22 @@ .macro JMP_NOSPEC reg:req #ifdef CONFIG_RETPOLINE ANNOTATE_NOSPEC_ALTERNATIVE - ALTERNATIVE_2 __stringify(ANNOTATE_RETPOLINE_SAFE; jmp *\reg), \ - __stringify(RETPOLINE_JMP \reg), X86_FEATURE_RETPOLINE, \ - __stringify(lfence; ANNOTATE_RETPOLINE_SAFE; jmp *\reg), X86_FEATURE_RETPOLINE_AMD + ALTERNATIVE_2 __stringify(ANNOTATE_RETPOLINE_SAFE; jmp *%\reg), \ + __stringify(RETPOLINE_JMP %\reg), X86_FEATURE_RETPOLINE,\ + __stringify(lfence; ANNOTATE_RETPOLINE_SAFE; jmp *%\reg), X86_FEATURE_RETPOLINE_AMD #else - jmp *\reg + jmp *%\reg #endif .endm .macro CALL_NOSPEC reg:req #ifdef CONFIG_RETPOLINE ANNOTATE_NOSPEC_ALTERNATIVE - ALTERNATIVE_2 __stringify(ANNOTATE_RETPOLINE_SAFE; call *\reg), \ - __stringify(RETPOLINE_CALL \reg), X86_FEATURE_RETPOLINE,\ - __stringify(lfence; ANNOTATE_RETPOLINE_SAFE; call *\reg), X86_FEATURE_RETPOLINE_AMD + ALTERNATIVE_2 __stringify(ANNOTATE_RETPOLINE_SAFE; call *%\reg),\ + __stringify(RETPOLINE_CALL %\reg), X86_FEATURE_RETPOLINE,\ + __stringify(lfence; ANNOTATE_RETPOLINE_SAFE; call *%\reg), X86_FEATURE_RETPOLINE_AMD #else - call *\reg + call *%\reg #endif .endm
arch/x86/kernel/ftrace_32.S +1 -1
@@ -189,5 +189,5 @@ SYM_CODE_END(ftrace_graph_caller) movl %eax, %ecx popl %edx popl %eax - JMP_NOSPEC %ecx + JMP_NOSPEC ecx #endif
arch/x86/kernel/ftrace_64.S +2 -2
@@ -301,7 +301,7 @@ SYM_INNER_LABEL(ftrace_stub, SYM_L_GLOBA * function tracing is enabled. */ movq ftrace_trace_function, %r8 - CALL_NOSPEC %r8 + CALL_NOSPEC r8 restore_mcount_regs jmp fgraph_trace
@@ -338,6 +338,6 @@ SYM_CODE_START(return_to_handler) movq 8(%rsp), %rdx movq (%rsp), %rax addq $24, %rsp - JMP_NOSPEC %rdi + JMP_NOSPEC rdi SYM_CODE_END(return_to_handler) #endif
arch/x86/lib/checksum_32.S +2 -2
@@ -153,7 +153,7 @@ SYM_FUNC_START(csum_partial) negl %ebx lea 45f(%ebx,%ebx,2), %ebx testl %esi, %esi - JMP_NOSPEC %ebx + JMP_NOSPEC ebx # Handle 2-byte-aligned regions 20: addw (%esi), %ax
@@ -436,7 +436,7 @@ SYM_FUNC_START(csum_partial_copy_generic andl $-32,%edx lea 3f(%ebx,%ebx), %ebx testl %esi, %esi - JMP_NOSPEC %ebx + JMP_NOSPEC ebx 1: addl $64,%esi addl $64,%edi SRC(movb -32(%edx),%bl) ; SRC(movb (%edx),%bl)
arch/x86/platform/efi/efi_stub_64.S +1 -1
@@ -21,7 +21,7 @@ SYM_FUNC_START(__efi_call) mov %r8, %r9 mov %rcx, %r8 mov %rsi, %rcx - CALL_NOSPEC %rdi + CALL_NOSPEC rdi leave ret SYM_FUNC_END(__efi_call)
[tip: objtool/core] x86: Change {JMP,CALL}_NOSPEC argument
The following commit has been merged into the objtool/core branch of tip:
The following commit has been merged into the objtool/core branch of tip:
Commit-ID: 34fdce6981b96920ced4e0ee56e9db3fb03a33f0 Gitweb: https://git.kernel.org/tip/34fdce6981b96920ced4e0ee56e9db3fb03a33f0 Author: Peter Zijlstra <[email protected]> AuthorDate: Wed, 22 Apr 2020 17:16:40 +02:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Thu, 30 Apr 2020 20:14:34 +02:00
x86: Change {JMP,CALL}_NOSPEC argument
In order to change the {JMP,CALL}_NOSPEC macros to call out-of-line versions of the retpoline magic, we need to remove the '%' from the argument, such that we can paste it onto symbol names.
--- arch/x86/crypto/aesni-intel_asm.S | 4 +-- arch/x86/crypto/camellia-aesni-avx-asm_64.S | 2 +- arch/x86/crypto/camellia-aesni-avx2-asm_64.S | 2 +- arch/x86/crypto/crc32c-pcl-intel-asm_64.S | 26 +++++++++---------- arch/x86/entry/entry_32.S | 6 ++-- arch/x86/entry/entry_64.S | 2 +- arch/x86/include/asm/nospec-branch.h | 16 ++++++------ arch/x86/kernel/ftrace_32.S | 2 +- arch/x86/kernel/ftrace_64.S | 4 +-- arch/x86/lib/checksum_32.S | 4 +-- arch/x86/platform/efi/efi_stub_64.S | 2 +- 11 files changed, 35 insertions(+), 35 deletions(-)
arch/x86/crypto/aesni-intel_asm.S +2 -2
@@ -2758,7 +2758,7 @@ SYM_FUNC_START(aesni_xts_crypt8) pxor INC, STATE4 movdqu IV, 0x30(OUTP) - CALL_NOSPEC %r11 + CALL_NOSPEC r11 movdqu 0x00(OUTP), INC pxor INC, STATE1
@@ -2803,7 +2803,7 @@ SYM_FUNC_START(aesni_xts_crypt8) _aesni_gf128mul_x_ble() movups IV, (IVP) - CALL_NOSPEC %r11 + CALL_NOSPEC r11 movdqu 0x40(OUTP), INC pxor INC, STATE1
arch/x86/crypto/camellia-aesni-avx-asm_64.S +1 -1
@@ -1228,7 +1228,7 @@ SYM_FUNC_START_LOCAL(camellia_xts_crypt_16way) vpxor 14 * 16(%rax), %xmm15, %xmm14; vpxor 15 * 16(%rax), %xmm15, %xmm15; - CALL_NOSPEC %r9; + CALL_NOSPEC r9; addq $(16 * 16), %rsp;
arch/x86/crypto/camellia-aesni-avx2-asm_64.S +1 -1
@@ -1339,7 +1339,7 @@ SYM_FUNC_START_LOCAL(camellia_xts_crypt_32way) vpxor 14 * 32(%rax), %ymm15, %ymm14; vpxor 15 * 32(%rax), %ymm15, %ymm15; - CALL_NOSPEC %r9; + CALL_NOSPEC r9; addq $(16 * 32), %rsp;
arch/x86/crypto/crc32c-pcl-intel-asm_64.S +13 -13
@@ -75,7 +75,7 @@ .text SYM_FUNC_START(crc_pcl) -#define bufp %rdi +#define bufp rdi #define bufp_dw %edi #define bufp_w %di #define bufp_b %dil
@@ -105,9 +105,9 @@ SYM_FUNC_START(crc_pcl) ## 1) ALIGN: ################################################################ - mov bufp, bufptmp # rdi = *buf - neg bufp - and $7, bufp # calculate the unalignment amount of + mov %bufp, bufptmp # rdi = *buf + neg %bufp + and $7, %bufp # calculate the unalignment amount of # the address je proc_block # Skip if aligned
@@ -123,13 +123,13 @@ SYM_FUNC_START(crc_pcl) do_align: #### Calculate CRC of unaligned bytes of the buffer (if any) movq (bufptmp), tmp # load a quadward from the buffer - add bufp, bufptmp # align buffer pointer for quadword + add %bufp, bufptmp # align buffer pointer for quadword # processing - sub bufp, len # update buffer length + sub %bufp, len # update buffer length align_loop: crc32b %bl, crc_init_dw # compute crc32 of 1-byte shr $8, tmp # get next byte - dec bufp + dec %bufp jne align_loop proc_block:
@@ -169,10 +169,10 @@ continue_block: xor crc2, crc2 ## branch into array - lea jump_table(%rip), bufp - movzxw (bufp, %rax, 2), len - lea crc_array(%rip), bufp - lea (bufp, len, 1), bufp + lea jump_table(%rip), %bufp + movzxw (%bufp, %rax, 2), len + lea crc_array(%rip), %bufp + lea (%bufp, len, 1), %bufp JMP_NOSPEC bufp ################################################################
@@ -218,9 +218,9 @@ LABEL crc_ %i ## 4) Combine three results: ################################################################ - lea (K_table-8)(%rip), bufp # first entry is for idx 1 + lea (K_table-8)(%rip), %bufp # first entry is for idx 1 shlq $3, %rax # rax *= 8 - pmovzxdq (bufp,%rax), %xmm0 # 2 consts: K1:K2 + pmovzxdq (%bufp,%rax), %xmm0 # 2 consts: K1:K2 leal (%eax,%eax,2), %eax # rax *= 3 (total *24) subq %rax, tmp # tmp -= rax*24
arch/x86/entry/entry_32.S +3 -3
@@ -816,7 +816,7 @@ SYM_CODE_START(ret_from_fork) /* kernel thread */ 1: movl %edi, %eax - CALL_NOSPEC %ebx + CALL_NOSPEC ebx /* * A kernel thread is allowed to return here after successfully * calling do_execve(). Exit to userspace to complete the execve()
@@ -1501,7 +1501,7 @@ SYM_CODE_START_LOCAL_NOALIGN(common_exception_read_cr2) TRACE_IRQS_OFF movl %esp, %eax # pt_regs pointer - CALL_NOSPEC %edi + CALL_NOSPEC edi jmp ret_from_exception SYM_CODE_END(common_exception_read_cr2)
@@ -1522,7 +1522,7 @@ SYM_CODE_START_LOCAL_NOALIGN(common_exception) TRACE_IRQS_OFF movl %esp, %eax # pt_regs pointer - CALL_NOSPEC %edi + CALL_NOSPEC edi jmp ret_from_exception SYM_CODE_END(common_exception)
arch/x86/entry/entry_64.S +1 -1
@@ -349,7 +349,7 @@ SYM_CODE_START(ret_from_fork) /* kernel thread */ UNWIND_HINT_EMPTY movq %r12, %rdi - CALL_NOSPEC %rbx + CALL_NOSPEC rbx /* * A kernel thread is allowed to return here after successfully * calling do_execve(). Exit to userspace to complete the execve()
arch/x86/include/asm/nospec-branch.h +8 -8
@@ -118,22 +118,22 @@ .macro JMP_NOSPEC reg:req #ifdef CONFIG_RETPOLINE ANNOTATE_NOSPEC_ALTERNATIVE - ALTERNATIVE_2 __stringify(ANNOTATE_RETPOLINE_SAFE; jmp *\reg), \ - __stringify(RETPOLINE_JMP \reg), X86_FEATURE_RETPOLINE, \ - __stringify(lfence; ANNOTATE_RETPOLINE_SAFE; jmp *\reg), X86_FEATURE_RETPOLINE_AMD + ALTERNATIVE_2 __stringify(ANNOTATE_RETPOLINE_SAFE; jmp *%\reg), \ + __stringify(RETPOLINE_JMP %\reg), X86_FEATURE_RETPOLINE,\ + __stringify(lfence; ANNOTATE_RETPOLINE_SAFE; jmp *%\reg), X86_FEATURE_RETPOLINE_AMD #else - jmp *\reg + jmp *%\reg #endif .endm .macro CALL_NOSPEC reg:req #ifdef CONFIG_RETPOLINE ANNOTATE_NOSPEC_ALTERNATIVE - ALTERNATIVE_2 __stringify(ANNOTATE_RETPOLINE_SAFE; call *\reg), \ - __stringify(RETPOLINE_CALL \reg), X86_FEATURE_RETPOLINE,\ - __stringify(lfence; ANNOTATE_RETPOLINE_SAFE; call *\reg), X86_FEATURE_RETPOLINE_AMD + ALTERNATIVE_2 __stringify(ANNOTATE_RETPOLINE_SAFE; call *%\reg),\ + __stringify(RETPOLINE_CALL %\reg), X86_FEATURE_RETPOLINE,\ + __stringify(lfence; ANNOTATE_RETPOLINE_SAFE; call *%\reg), X86_FEATURE_RETPOLINE_AMD #else - call *\reg + call *%\reg #endif .endm
arch/x86/kernel/ftrace_32.S +1 -1
@@ -189,5 +189,5 @@ return_to_handler: movl %eax, %ecx popl %edx popl %eax - JMP_NOSPEC %ecx + JMP_NOSPEC ecx #endif
arch/x86/kernel/ftrace_64.S +2 -2
@@ -301,7 +301,7 @@ trace: * function tracing is enabled. */ movq ftrace_trace_function, %r8 - CALL_NOSPEC %r8 + CALL_NOSPEC r8 restore_mcount_regs jmp fgraph_trace
@@ -338,6 +338,6 @@ SYM_CODE_START(return_to_handler) movq 8(%rsp), %rdx movq (%rsp), %rax addq $24, %rsp - JMP_NOSPEC %rdi + JMP_NOSPEC rdi SYM_CODE_END(return_to_handler) #endif
arch/x86/lib/checksum_32.S +2 -2
@@ -153,7 +153,7 @@ SYM_FUNC_START(csum_partial) negl %ebx lea 45f(%ebx,%ebx,2), %ebx testl %esi, %esi - JMP_NOSPEC %ebx + JMP_NOSPEC ebx # Handle 2-byte-aligned regions 20: addw (%esi), %ax
@@ -436,7 +436,7 @@ SYM_FUNC_START(csum_partial_copy_generic) andl $-32,%edx lea 3f(%ebx,%ebx), %ebx testl %esi, %esi - JMP_NOSPEC %ebx + JMP_NOSPEC ebx 1: addl $64,%esi addl $64,%edi SRC(movb -32(%edx),%bl) ; SRC(movb (%edx),%bl)
arch/x86/platform/efi/efi_stub_64.S +1 -1
@@ -21,7 +21,7 @@ SYM_FUNC_START(__efi_call) mov %r8, %r9 mov %rcx, %r8 mov %rsi, %rcx - CALL_NOSPEC %rdi + CALL_NOSPEC rdi leave ret SYM_FUNC_END(__efi_call)
Peter Zijlstra
maintainerPATCH v2 14/14 x86/retpoline: Fix retpoline unwind
In reply to Peter ZijlstraCurrently objtool cannot understand retpolines, and thus cannot generate ORC unwind information for them. This means that we cannot unwind from the middle of a retpoline.
The recent ANNOTATE_INTRA_FUNCTION_CALL and UNWIND_HINT_RET_OFFSET support in objtool enables it to understand the basic retpoline construct. A further problem is that the ORC unwind information is alternative invariant; IOW. every alternative should have the same ORC, retpolines obviously violate this. This means we need to out-of-line them.
Since all GCC generated code already uses out-of-line retpolines, this should not affect performance much, if anything.
This will enable objtool to generate valid ORC data for the out-of-line copies, which means we can correctly and reliably unwind through a retpoline.
--- arch/x86/include/asm/asm-prototypes.h | 7 ++++ arch/x86/include/asm/nospec-branch.h | 56 ++++------------------------------ arch/x86/lib/retpoline.S | 26 +++++++++++++-- 3 files changed, 38 insertions(+), 51 deletions(-)
arch/x86/include/asm/asm-prototypes.h +7 -0
@@ -21,8 +21,15 @@ extern void cmpxchg8b_emu(void);#define DECL_INDIRECT_THUNK (reg) \ extern asmlinkage void __x86_indirect_thunk_ ## reg (void); +#define DECL_RETPOLINE (reg) \ + extern asmlinkage void __x86_retpoline_ ## reg (void); +#undef GEN#define GEN (reg) DECL_INDIRECT_THUNK(reg)#include <asm/GEN-for-each-reg.h> +#undef GEN +#define GEN (reg) DECL_RETPOLINE(reg) +#include <asm/GEN-for-each-reg.h> +#endif /* CONFIG_RETPOLINE */
arch/x86/include/asm/nospec-branch.h +8 -48
100 lines not on this page · raw message
arch/x86/lib/retpoline.S +23 -3
@@ -7,15 +7,31 @@ #include <asm/alternative-asm.h> #include <asm/export.h> #include <asm/nospec-branch.h> +#include <asm/unwind_hints.h> +#include <asm/frame.h> .macro THUNK reg .section .text.__x86.indirect_thunk + .align 32 SYM_FUNC_START(__x86_indirect_thunk_\reg) - CFI_STARTPROC - JMP_NOSPEC %\reg - CFI_ENDPROC + JMP_NOSPEC \reg SYM_FUNC_END(__x86_indirect_thunk_\reg) + +SYM_FUNC_START_NOALIGN(__x86_retpoline_\reg) + ANNOTATE_INTRA_FUNCTION_CALL + call .Ldo_rop_\@ +.Lspec_trap_\@: + UNWIND_HINT_EMPTY + pause + lfence + jmp .Lspec_trap_\@ +.Ldo_rop_\@: + mov %\reg, (%_ASM_SP) + UNWIND_HINT_RET_OFFSET + ret +SYM_FUNC_END(__x86_retpoline_\reg) + .endm /*
@@ -32,6 +48,7 @@ SYM_FUNC_END(__x86_indirect_thunk_\reg) #define __EXPORT_THUNK(sym) _ASM_NOKPROBE(sym); EXPORT_SYMBOL(sym) #define EXPORT_THUNK(reg) __EXPORT_THUNK(__x86_indirect_thunk_ ## reg) +#define EXPORT_RETPOLINE(reg) __EXPORT_THUNK(__x86_retpoline_ ## reg) #undef GEN #define GEN(reg) THUNK reg
@@ -41,3 +58,6 @@ SYM_FUNC_END(__x86_indirect_thunk_\reg) #define GEN(reg) EXPORT_THUNK(reg) #include <asm/GEN-for-each-reg.h> +#undef GEN +#define GEN(reg) EXPORT_RETPOLINE(reg) +#include <asm/GEN-for-each-reg.h>
[tip: objtool/core] x86/retpoline: Fix retpoline unwind
The following commit has been merged into the objtool/core branch of tip:
The following commit has been merged into the objtool/core branch of tip:
Commit-ID: cc1ac9c792810b93783a7de344f428922af8d98c Gitweb: https://git.kernel.org/tip/cc1ac9c792810b93783a7de344f428922af8d98c Author: Peter Zijlstra <[email protected]> AuthorDate: Thu, 16 Apr 2020 14:34:26 +02:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Thu, 30 Apr 2020 20:14:34 +02:00
x86/retpoline: Fix retpoline unwind
Currently objtool cannot understand retpolines, and thus cannot generate ORC unwind information for them. This means that we cannot unwind from the middle of a retpoline.
The recent ANNOTATE_INTRA_FUNCTION_CALL and UNWIND_HINT_RET_OFFSET support in objtool enables it to understand the basic retpoline construct. A further problem is that the ORC unwind information is alternative invariant; IOW. every alternative should have the same ORC, retpolines obviously violate this. This means we need to out-of-line them.
Since all GCC generated code already uses out-of-line retpolines, this should not affect performance much, if anything.
This will enable objtool to generate valid ORC data for the out-of-line copies, which means we can correctly and reliably unwind through a retpoline.
--- arch/x86/include/asm/asm-prototypes.h | 7 +++- arch/x86/include/asm/nospec-branch.h | 56 +++----------------------- arch/x86/lib/retpoline.S | 26 ++++++++++-- 3 files changed, 38 insertions(+), 51 deletions(-)
arch/x86/include/asm/asm-prototypes.h +7 -0
@@ -21,8 +21,15 @@ extern void cmpxchg8b_emu(void);#define DECL_INDIRECT_THUNK (reg) \ extern asmlinkage void __x86_indirect_thunk_ ## reg (void); +#define DECL_RETPOLINE (reg) \ + extern asmlinkage void __x86_retpoline_ ## reg (void); +#undef GEN#define GEN (reg) DECL_INDIRECT_THUNK(reg)#include <asm/GEN-for-each-reg.h> +#undef GEN +#define GEN (reg) DECL_RETPOLINE(reg) +#include <asm/GEN-for-each-reg.h> +#endif /* CONFIG_RETPOLINE */
arch/x86/include/asm/nospec-branch.h +8 -48
100 lines not on this page · raw message
arch/x86/lib/retpoline.S +23 -3
@@ -7,15 +7,31 @@ #include <asm/alternative-asm.h> #include <asm/export.h> #include <asm/nospec-branch.h> +#include <asm/unwind_hints.h> +#include <asm/frame.h> .macro THUNK reg .section .text.__x86.indirect_thunk + .align 32 SYM_FUNC_START(__x86_indirect_thunk_\reg) - CFI_STARTPROC - JMP_NOSPEC %\reg - CFI_ENDPROC + JMP_NOSPEC \reg SYM_FUNC_END(__x86_indirect_thunk_\reg) + +SYM_FUNC_START_NOALIGN(__x86_retpoline_\reg) + ANNOTATE_INTRA_FUNCTION_CALL + call .Ldo_rop_\@ +.Lspec_trap_\@: + UNWIND_HINT_EMPTY + pause + lfence + jmp .Lspec_trap_\@ +.Ldo_rop_\@: + mov %\reg, (%_ASM_SP) + UNWIND_HINT_RET_OFFSET + ret +SYM_FUNC_END(__x86_retpoline_\reg) + .endm /*
@@ -32,6 +48,7 @@ SYM_FUNC_END(__x86_indirect_thunk_\reg) #define __EXPORT_THUNK(sym) _ASM_NOKPROBE(sym); EXPORT_SYMBOL(sym) #define EXPORT_THUNK(reg) __EXPORT_THUNK(__x86_indirect_thunk_ ## reg) +#define EXPORT_RETPOLINE(reg) __EXPORT_THUNK(__x86_retpoline_ ## reg) #undef GEN #define GEN(reg) THUNK reg
@@ -41,3 +58,6 @@ SYM_FUNC_END(__x86_indirect_thunk_\reg) #define GEN(reg) EXPORT_THUNK(reg) #include <asm/GEN-for-each-reg.h> +#undef GEN +#define GEN(reg) EXPORT_RETPOLINE(reg) +#include <asm/GEN-for-each-reg.h>
Quoted 8 lines · Peter Zijlstra
Hi,
Based on Alexandre's patches, here's a few that go on top of tip/objtool/core.
With these patches on objtool can completely understand retpolines and RSB stuffing, which means it can emit valid ORC unwind information for them, which in turn means we can now unwind through a retpoline.
Quoted 5 lines
New since last time:
- 1-3, alternatives vs ORC unwind
- 7-9: implement some suggestions from Julien
- addressed feedback
For patches 2-14:
Instead of patch 1, maybe you could grab Julien's patch to drop the useless warning; and also grab the alt_group numbering and the "orig->alt_group = true" bits from Alexandre's patch.
Signature · 1 line
Josh
Peter Zijlstra
maintainerPATCH 1/1 objtool: Remove check preventing branches within alternative
In reply to Peter ZijlstraSubject: objtool: Remove check preventing branches within alternative
From: Julien Thierry <[email protected]>
Date: Fri, 27 Mar 2020 15:28:42 +0000
From: Julien Thierry <[email protected]>
While jumping from outside an alternative region to the middle of an alternative region is very likely wrong, jumping from an alternative region into the same region is valid. It is a common pattern on arm64.
The first pattern is unlikely to happen in practice and checking only for this adds a lot of complexity.
Just remove the current check.
--- tools/objtool/check.c | 6 ------ 1 file changed, 6 deletions(-)
tools/objtool/check.c +0 -6
@@ -2180,12 +2180,6 @@ static int validate_branch(struct objtoo sec = insn->sec; -if (insn->alt_group &&list_empty (&insn->alts)) { -WARN_FUNC ("don't know how to handle branch to middle of alternative instruction group" , - sec, insn->offset); -return 1 ; - } -while (1 ) { next_insn =next_insn_same_sec (file, insn);
Peter Zijlstra
maintainerPATCH 1/1 objtool: Uniquely identify alternative instruction groups
In reply to Peter ZijlstraSubject: objtool: Uniquely identify alternative instruction groups
From: Alexandre Chartre <[email protected]>
Date: Tue, 14 Apr 2020 12:36:11 +0200
From: Alexandre Chartre <[email protected]>
Assign a unique identifier to every alternative instruction group in order to be able to tell which instructions belong to what alternative.
--- tools/objtool/check.c | 26 ++++++++++++++++++++------ tools/objtool/check.h | 3 ++- 2 files changed, 22 insertions(+), 7 deletions(-)
tools/objtool/check.c +5 -1
@@ -770,7 +770,9 @@ static int handle_group_alt(struct objto struct instruction *orig_insn, struct instruction **new_insn) { +static unsigned int alt_group_next_index =1 ;struct instruction *last_orig_insn, *last_new_insn, *insn, *fake_jump =NULL ; +unsigned int alt_group = alt_group_next_index++;unsigned long dest_off; last_orig_insn =NULL ;
@@ -779,7 +781,7 @@ static int handle_group_alt(struct objtoif (insn->offset >= special_alt->orig_off + special_alt->orig_len)break ; - insn->alt_group = true; + insn->alt_group = alt_group; last_orig_insn = insn; }
@@ -813,6 +815,7 @@ static int handle_group_alt(struct objto } last_new_insn =NULL ; + alt_group = alt_group_next_index++; insn = *new_insn;sec_for_each_insn_from (file, insn) {if (insn->offset >= special_alt->new_off + special_alt->new_len)
@@ -822,6 +825,7 @@ static int handle_group_alt(struct objto insn->ignore = orig_insn->ignore_alts; insn->func = orig_insn->func; + insn->alt_group = alt_group;/* * Since alternative replacement code is copy/pasted by the
tools/objtool/check.h +2 -1
@@ -30,12 +30,13 @@ struct instruction {unsigned int len;enum insn_type type;unsigned long immediate; -bool alt_group, dead_end, ignore, ignore_alts; +bool dead_end, ignore, ignore_alts;bool hint;bool retpoline_safe;s8 instr;u8 visited;u8 ret_offset; +int alt_group;struct symbol *call_dest;struct instruction *jump_dest;struct instruction *first_jump_src;
Quoted 8 lines · Peter Zijlstra
Hi,
Based on Alexandre's patches, here's a few that go on top of tip/objtool/core.
With these patches on objtool can completely understand retpolines and RSB stuffing, which means it can emit valid ORC unwind information for them, which in turn means we can now unwind through a retpoline.
Quoted 5 lines
New since last time:
- 1-3, alternatives vs ORC unwind
- 7-9: implement some suggestions from Julien
- addressed feedback
You can add my
to patches 1A, 1B and 2-10 (objtool patches and updated smap fix). The other four patches should be fine too, but I am not well versed in the speculation stuff.
Miroslav