2005-06-26 05:58:02 +08:00
|
|
|
/*
|
|
|
|
* relocate_kernel.S - put the kernel image in place to boot
|
|
|
|
* Copyright (C) 2002-2005 Eric Biederman <ebiederm@xmission.com>
|
|
|
|
*
|
|
|
|
* This source code is licensed under the GNU General Public License,
|
|
|
|
* Version 2. See the file COPYING for more details.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/linkage.h>
|
2009-02-14 03:14:01 +08:00
|
|
|
#include <asm/page_types.h>
|
2006-09-26 16:52:38 +08:00
|
|
|
#include <asm/kexec.h>
|
2008-03-23 05:00:08 +08:00
|
|
|
#include <asm/processor-flags.h>
|
2009-02-14 03:14:01 +08:00
|
|
|
#include <asm/pgtable_types.h>
|
2005-06-26 05:58:02 +08:00
|
|
|
|
2006-09-26 16:52:38 +08:00
|
|
|
/*
|
|
|
|
* Must be relocatable PIC code callable as a C function
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define PTR(x) (x << 3)
|
2008-03-23 05:00:09 +08:00
|
|
|
#define PAGE_ATTR (_PAGE_PRESENT | _PAGE_RW | _PAGE_ACCESSED | _PAGE_DIRTY)
|
2006-09-26 16:52:38 +08:00
|
|
|
|
2009-03-10 10:57:16 +08:00
|
|
|
/*
|
|
|
|
* control_page + KEXEC_CONTROL_CODE_MAX_SIZE
|
|
|
|
* ~ control_page + PAGE_SIZE are used as data storage and stack for
|
|
|
|
* jumping back
|
|
|
|
*/
|
|
|
|
#define DATA(offset) (KEXEC_CONTROL_CODE_MAX_SIZE+(offset))
|
|
|
|
|
|
|
|
/* Minimal CPU state */
|
|
|
|
#define RSP DATA(0x0)
|
|
|
|
#define CR0 DATA(0x8)
|
|
|
|
#define CR3 DATA(0x10)
|
|
|
|
#define CR4 DATA(0x18)
|
|
|
|
|
|
|
|
/* other data */
|
|
|
|
#define CP_PA_TABLE_PAGE DATA(0x20)
|
|
|
|
#define CP_PA_SWAP_PAGE DATA(0x28)
|
|
|
|
#define CP_PA_BACKUP_PAGES_MAP DATA(0x30)
|
|
|
|
|
2006-09-26 16:52:38 +08:00
|
|
|
.text
|
2008-03-22 04:12:14 +08:00
|
|
|
.align PAGE_SIZE
|
2005-06-26 05:58:02 +08:00
|
|
|
.code64
|
2006-09-26 16:52:38 +08:00
|
|
|
.globl relocate_kernel
|
|
|
|
relocate_kernel:
|
2009-03-10 10:56:57 +08:00
|
|
|
/*
|
|
|
|
* %rdi indirection_page
|
2006-09-26 16:52:38 +08:00
|
|
|
* %rsi page_list
|
|
|
|
* %rdx start address
|
2009-03-10 10:57:16 +08:00
|
|
|
* %rcx preserve_context
|
2017-07-29 00:01:16 +08:00
|
|
|
* %r8 sme_active
|
2006-09-26 16:52:38 +08:00
|
|
|
*/
|
|
|
|
|
2009-03-10 10:57:16 +08:00
|
|
|
/* Save the CPU context, used for jumping back */
|
|
|
|
pushq %rbx
|
|
|
|
pushq %rbp
|
|
|
|
pushq %r12
|
|
|
|
pushq %r13
|
|
|
|
pushq %r14
|
|
|
|
pushq %r15
|
|
|
|
pushf
|
|
|
|
|
|
|
|
movq PTR(VA_CONTROL_PAGE)(%rsi), %r11
|
|
|
|
movq %rsp, RSP(%r11)
|
|
|
|
movq %cr0, %rax
|
|
|
|
movq %rax, CR0(%r11)
|
|
|
|
movq %cr3, %rax
|
|
|
|
movq %rax, CR3(%r11)
|
|
|
|
movq %cr4, %rax
|
|
|
|
movq %rax, CR4(%r11)
|
|
|
|
|
2018-01-29 19:08:45 +08:00
|
|
|
/* Save CR4. Required to enable the right paging mode later. */
|
|
|
|
movq %rax, %r13
|
|
|
|
|
2005-06-26 05:58:02 +08:00
|
|
|
/* zero out flags, and disable interrupts */
|
|
|
|
pushq $0
|
|
|
|
popfq
|
|
|
|
|
2017-07-29 00:01:16 +08:00
|
|
|
/* Save SME active flag */
|
|
|
|
movq %r8, %r12
|
|
|
|
|
2009-03-10 10:56:57 +08:00
|
|
|
/*
|
|
|
|
* get physical address of control page now
|
|
|
|
* this is impossible after page table switch
|
|
|
|
*/
|
2006-09-26 16:52:38 +08:00
|
|
|
movq PTR(PA_CONTROL_PAGE)(%rsi), %r8
|
|
|
|
|
|
|
|
/* get physical address of page table now too */
|
2009-03-10 10:57:16 +08:00
|
|
|
movq PTR(PA_TABLE_PAGE)(%rsi), %r9
|
|
|
|
|
|
|
|
/* get physical address of swap page now */
|
|
|
|
movq PTR(PA_SWAP_PAGE)(%rsi), %r10
|
|
|
|
|
|
|
|
/* save some information for jumping back */
|
|
|
|
movq %r9, CP_PA_TABLE_PAGE(%r11)
|
|
|
|
movq %r10, CP_PA_SWAP_PAGE(%r11)
|
|
|
|
movq %rdi, CP_PA_BACKUP_PAGES_MAP(%r11)
|
2005-06-26 05:58:02 +08:00
|
|
|
|
2009-02-03 14:22:48 +08:00
|
|
|
/* Switch to the identity mapped page tables */
|
2009-03-10 10:57:16 +08:00
|
|
|
movq %r9, %cr3
|
2006-09-26 16:52:38 +08:00
|
|
|
|
|
|
|
/* setup a new stack at the end of the physical control page */
|
2008-03-23 05:00:07 +08:00
|
|
|
lea PAGE_SIZE(%r8), %rsp
|
2006-09-26 16:52:38 +08:00
|
|
|
|
|
|
|
/* jump to identity mapped page */
|
|
|
|
addq $(identity_mapped - relocate_kernel), %r8
|
|
|
|
pushq %r8
|
|
|
|
ret
|
|
|
|
|
|
|
|
identity_mapped:
|
2011-07-14 09:34:37 +08:00
|
|
|
/* set return address to 0 if not preserving context */
|
|
|
|
pushq $0
|
2006-09-26 16:52:38 +08:00
|
|
|
/* store the start address on the stack */
|
|
|
|
pushq %rdx
|
2005-06-26 05:58:02 +08:00
|
|
|
|
2009-03-10 10:56:57 +08:00
|
|
|
/*
|
|
|
|
* Set cr0 to a known state:
|
2008-03-23 05:00:08 +08:00
|
|
|
* - Paging enabled
|
|
|
|
* - Alignment check disabled
|
|
|
|
* - Write protect disabled
|
|
|
|
* - No task switch
|
|
|
|
* - Don't do FP software emulation.
|
|
|
|
* - Proctected mode enabled
|
2005-06-26 05:58:02 +08:00
|
|
|
*/
|
|
|
|
movq %cr0, %rax
|
2008-03-23 05:00:08 +08:00
|
|
|
andq $~(X86_CR0_AM | X86_CR0_WP | X86_CR0_TS | X86_CR0_EM), %rax
|
|
|
|
orl $(X86_CR0_PG | X86_CR0_PE), %eax
|
2005-06-26 05:58:02 +08:00
|
|
|
movq %rax, %cr0
|
|
|
|
|
2009-03-10 10:56:57 +08:00
|
|
|
/*
|
|
|
|
* Set cr4 to a known state:
|
2008-03-23 05:00:08 +08:00
|
|
|
* - physical address extension enabled
|
2018-01-29 19:08:45 +08:00
|
|
|
* - 5-level paging, if it was enabled before
|
2005-06-26 05:58:02 +08:00
|
|
|
*/
|
2015-04-01 01:00:10 +08:00
|
|
|
movl $X86_CR4_PAE, %eax
|
2018-01-29 19:08:45 +08:00
|
|
|
testq $X86_CR4_LA57, %r13
|
|
|
|
jz 1f
|
|
|
|
orl $X86_CR4_LA57, %eax
|
|
|
|
1:
|
2005-06-26 05:58:02 +08:00
|
|
|
movq %rax, %cr4
|
|
|
|
|
|
|
|
jmp 1f
|
|
|
|
1:
|
|
|
|
|
2009-02-03 14:22:48 +08:00
|
|
|
/* Flush the TLB (needed?) */
|
2009-03-10 10:57:16 +08:00
|
|
|
movq %r9, %cr3
|
|
|
|
|
2017-07-29 00:01:16 +08:00
|
|
|
/*
|
|
|
|
* If SME is active, there could be old encrypted cache line
|
|
|
|
* entries that will conflict with the now unencrypted memory
|
|
|
|
* used by kexec. Flush the caches before copying the kernel.
|
|
|
|
*/
|
|
|
|
testq %r12, %r12
|
|
|
|
jz 1f
|
|
|
|
wbinvd
|
|
|
|
1:
|
|
|
|
|
2009-03-10 10:57:16 +08:00
|
|
|
movq %rcx, %r11
|
|
|
|
call swap_pages
|
|
|
|
|
|
|
|
/*
|
|
|
|
* To be certain of avoiding problems with self-modifying code
|
|
|
|
* I need to execute a serializing instruction here.
|
|
|
|
* So I flush the TLB by reloading %cr3 here, it's handy,
|
|
|
|
* and not processor dependent.
|
|
|
|
*/
|
|
|
|
movq %cr3, %rax
|
|
|
|
movq %rax, %cr3
|
|
|
|
|
|
|
|
/*
|
|
|
|
* set all of the registers to known values
|
|
|
|
* leave %rsp alone
|
|
|
|
*/
|
|
|
|
|
|
|
|
testq %r11, %r11
|
|
|
|
jnz 1f
|
2013-06-21 12:16:00 +08:00
|
|
|
xorl %eax, %eax
|
|
|
|
xorl %ebx, %ebx
|
|
|
|
xorl %ecx, %ecx
|
|
|
|
xorl %edx, %edx
|
|
|
|
xorl %esi, %esi
|
|
|
|
xorl %edi, %edi
|
|
|
|
xorl %ebp, %ebp
|
|
|
|
xorl %r8d, %r8d
|
|
|
|
xorl %r9d, %r9d
|
|
|
|
xorl %r10d, %r10d
|
|
|
|
xorl %r11d, %r11d
|
|
|
|
xorl %r12d, %r12d
|
|
|
|
xorl %r13d, %r13d
|
|
|
|
xorl %r14d, %r14d
|
|
|
|
xorl %r15d, %r15d
|
2009-03-10 10:57:16 +08:00
|
|
|
|
|
|
|
ret
|
|
|
|
|
|
|
|
1:
|
|
|
|
popq %rdx
|
|
|
|
leaq PAGE_SIZE(%r10), %rsp
|
|
|
|
call *%rdx
|
|
|
|
|
|
|
|
/* get the re-entry point of the peer system */
|
|
|
|
movq 0(%rsp), %rbp
|
|
|
|
call 1f
|
|
|
|
1:
|
|
|
|
popq %r8
|
|
|
|
subq $(1b - relocate_kernel), %r8
|
|
|
|
movq CP_PA_SWAP_PAGE(%r8), %r10
|
|
|
|
movq CP_PA_BACKUP_PAGES_MAP(%r8), %rdi
|
|
|
|
movq CP_PA_TABLE_PAGE(%r8), %rax
|
|
|
|
movq %rax, %cr3
|
|
|
|
lea PAGE_SIZE(%r8), %rsp
|
|
|
|
call swap_pages
|
|
|
|
movq $virtual_mapped, %rax
|
|
|
|
pushq %rax
|
|
|
|
ret
|
|
|
|
|
|
|
|
virtual_mapped:
|
|
|
|
movq RSP(%r8), %rsp
|
|
|
|
movq CR4(%r8), %rax
|
|
|
|
movq %rax, %cr4
|
|
|
|
movq CR3(%r8), %rax
|
|
|
|
movq CR0(%r8), %r8
|
|
|
|
movq %rax, %cr3
|
|
|
|
movq %r8, %cr0
|
|
|
|
movq %rbp, %rax
|
|
|
|
|
|
|
|
popf
|
|
|
|
popq %r15
|
|
|
|
popq %r14
|
|
|
|
popq %r13
|
|
|
|
popq %r12
|
|
|
|
popq %rbp
|
|
|
|
popq %rbx
|
|
|
|
ret
|
2005-06-26 05:58:02 +08:00
|
|
|
|
|
|
|
/* Do the copies */
|
2009-03-10 10:57:16 +08:00
|
|
|
swap_pages:
|
2005-06-26 05:58:02 +08:00
|
|
|
movq %rdi, %rcx /* Put the page_list in %rcx */
|
2013-06-21 12:16:00 +08:00
|
|
|
xorl %edi, %edi
|
|
|
|
xorl %esi, %esi
|
2005-06-26 05:58:02 +08:00
|
|
|
jmp 1f
|
|
|
|
|
|
|
|
0: /* top, read another word for the indirection page */
|
|
|
|
|
|
|
|
movq (%rbx), %rcx
|
|
|
|
addq $8, %rbx
|
|
|
|
1:
|
x86/asm: Optimize unnecessarily wide TEST instructions
By the nature of the TEST operation, it is often possible to test
a narrower part of the operand:
"testl $3, mem" -> "testb $3, mem",
"testq $3, %rcx" -> "testb $3, %cl"
This results in shorter instructions, because the TEST instruction
has no sign-entending byte-immediate forms unlike other ALU ops.
Note that this change does not create any LCP (Length-Changing Prefix)
stalls, which happen when adding a 0x66 prefix, which happens when
16-bit immediates are used, which changes such TEST instructions:
[test_opcode] [modrm] [imm32]
to:
[0x66] [test_opcode] [modrm] [imm16]
where [imm16] has a *different length* now: 2 bytes instead of 4.
This confuses the decoder and slows down execution.
REX prefixes were carefully designed to almost never hit this case:
adding REX prefix does not change instruction length except MOVABS
and MOV [addr],RAX instruction.
This patch does not add instructions which would use a 0x66 prefix,
code changes in assembly are:
-48 f7 07 01 00 00 00 testq $0x1,(%rdi)
+f6 07 01 testb $0x1,(%rdi)
-48 f7 c1 01 00 00 00 test $0x1,%rcx
+f6 c1 01 test $0x1,%cl
-48 f7 c1 02 00 00 00 test $0x2,%rcx
+f6 c1 02 test $0x2,%cl
-41 f7 c2 01 00 00 00 test $0x1,%r10d
+41 f6 c2 01 test $0x1,%r10b
-48 f7 c1 04 00 00 00 test $0x4,%rcx
+f6 c1 04 test $0x4,%cl
-48 f7 c1 08 00 00 00 test $0x8,%rcx
+f6 c1 08 test $0x8,%cl
Linus further notes:
"There are no stalls from using 8-bit instruction forms.
Now, changing from 64-bit or 32-bit 'test' instructions to 8-bit ones
*could* cause problems if it ends up having forwarding issues, so that
instead of just forwarding the result, you end up having to wait for
it to be stable in the L1 cache (or possibly the register file). The
forwarding from the store buffer is simplest and most reliable if the
read is done at the exact same address and the exact same size as the
write that gets forwarded.
But that's true only if:
(a) the write was very recent and is still in the write queue. I'm
not sure that's the case here anyway.
(b) on at least most Intel microarchitectures, you have to test a
different byte than the lowest one (so forwarding a 64-bit write
to a 8-bit read ends up working fine, as long as the 8-bit read
is of the low 8 bits of the written data).
A very similar issue *might* show up for registers too, not just
memory writes, if you use 'testb' with a high-byte register (where
instead of forwarding the value from the original producer it needs to
go through the register file and then shifted). But it's mainly a
problem for store buffers.
But afaik, the way Denys changed the test instructions, neither of the
above issues should be true.
The real problem for store buffer forwarding tends to be "write 8
bits, read 32 bits". That can be really surprisingly expensive,
because the read ends up having to wait until the write has hit the
cacheline, and we might talk tens of cycles of latency here. But
"write 32 bits, read the low 8 bits" *should* be fast on pretty much
all x86 chips, afaik."
Signed-off-by: Denys Vlasenko <dvlasenk@redhat.com>
Acked-by: Andy Lutomirski <luto@amacapital.net>
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Will Drewry <wad@chromium.org>
Link: http://lkml.kernel.org/r/1425675332-31576-1-git-send-email-dvlasenk@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-03-07 04:55:32 +08:00
|
|
|
testb $0x1, %cl /* is it a destination page? */
|
2005-06-26 05:58:02 +08:00
|
|
|
jz 2f
|
|
|
|
movq %rcx, %rdi
|
|
|
|
andq $0xfffffffffffff000, %rdi
|
|
|
|
jmp 0b
|
|
|
|
2:
|
x86/asm: Optimize unnecessarily wide TEST instructions
By the nature of the TEST operation, it is often possible to test
a narrower part of the operand:
"testl $3, mem" -> "testb $3, mem",
"testq $3, %rcx" -> "testb $3, %cl"
This results in shorter instructions, because the TEST instruction
has no sign-entending byte-immediate forms unlike other ALU ops.
Note that this change does not create any LCP (Length-Changing Prefix)
stalls, which happen when adding a 0x66 prefix, which happens when
16-bit immediates are used, which changes such TEST instructions:
[test_opcode] [modrm] [imm32]
to:
[0x66] [test_opcode] [modrm] [imm16]
where [imm16] has a *different length* now: 2 bytes instead of 4.
This confuses the decoder and slows down execution.
REX prefixes were carefully designed to almost never hit this case:
adding REX prefix does not change instruction length except MOVABS
and MOV [addr],RAX instruction.
This patch does not add instructions which would use a 0x66 prefix,
code changes in assembly are:
-48 f7 07 01 00 00 00 testq $0x1,(%rdi)
+f6 07 01 testb $0x1,(%rdi)
-48 f7 c1 01 00 00 00 test $0x1,%rcx
+f6 c1 01 test $0x1,%cl
-48 f7 c1 02 00 00 00 test $0x2,%rcx
+f6 c1 02 test $0x2,%cl
-41 f7 c2 01 00 00 00 test $0x1,%r10d
+41 f6 c2 01 test $0x1,%r10b
-48 f7 c1 04 00 00 00 test $0x4,%rcx
+f6 c1 04 test $0x4,%cl
-48 f7 c1 08 00 00 00 test $0x8,%rcx
+f6 c1 08 test $0x8,%cl
Linus further notes:
"There are no stalls from using 8-bit instruction forms.
Now, changing from 64-bit or 32-bit 'test' instructions to 8-bit ones
*could* cause problems if it ends up having forwarding issues, so that
instead of just forwarding the result, you end up having to wait for
it to be stable in the L1 cache (or possibly the register file). The
forwarding from the store buffer is simplest and most reliable if the
read is done at the exact same address and the exact same size as the
write that gets forwarded.
But that's true only if:
(a) the write was very recent and is still in the write queue. I'm
not sure that's the case here anyway.
(b) on at least most Intel microarchitectures, you have to test a
different byte than the lowest one (so forwarding a 64-bit write
to a 8-bit read ends up working fine, as long as the 8-bit read
is of the low 8 bits of the written data).
A very similar issue *might* show up for registers too, not just
memory writes, if you use 'testb' with a high-byte register (where
instead of forwarding the value from the original producer it needs to
go through the register file and then shifted). But it's mainly a
problem for store buffers.
But afaik, the way Denys changed the test instructions, neither of the
above issues should be true.
The real problem for store buffer forwarding tends to be "write 8
bits, read 32 bits". That can be really surprisingly expensive,
because the read ends up having to wait until the write has hit the
cacheline, and we might talk tens of cycles of latency here. But
"write 32 bits, read the low 8 bits" *should* be fast on pretty much
all x86 chips, afaik."
Signed-off-by: Denys Vlasenko <dvlasenk@redhat.com>
Acked-by: Andy Lutomirski <luto@amacapital.net>
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Will Drewry <wad@chromium.org>
Link: http://lkml.kernel.org/r/1425675332-31576-1-git-send-email-dvlasenk@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-03-07 04:55:32 +08:00
|
|
|
testb $0x2, %cl /* is it an indirection page? */
|
2005-06-26 05:58:02 +08:00
|
|
|
jz 2f
|
|
|
|
movq %rcx, %rbx
|
|
|
|
andq $0xfffffffffffff000, %rbx
|
|
|
|
jmp 0b
|
|
|
|
2:
|
x86/asm: Optimize unnecessarily wide TEST instructions
By the nature of the TEST operation, it is often possible to test
a narrower part of the operand:
"testl $3, mem" -> "testb $3, mem",
"testq $3, %rcx" -> "testb $3, %cl"
This results in shorter instructions, because the TEST instruction
has no sign-entending byte-immediate forms unlike other ALU ops.
Note that this change does not create any LCP (Length-Changing Prefix)
stalls, which happen when adding a 0x66 prefix, which happens when
16-bit immediates are used, which changes such TEST instructions:
[test_opcode] [modrm] [imm32]
to:
[0x66] [test_opcode] [modrm] [imm16]
where [imm16] has a *different length* now: 2 bytes instead of 4.
This confuses the decoder and slows down execution.
REX prefixes were carefully designed to almost never hit this case:
adding REX prefix does not change instruction length except MOVABS
and MOV [addr],RAX instruction.
This patch does not add instructions which would use a 0x66 prefix,
code changes in assembly are:
-48 f7 07 01 00 00 00 testq $0x1,(%rdi)
+f6 07 01 testb $0x1,(%rdi)
-48 f7 c1 01 00 00 00 test $0x1,%rcx
+f6 c1 01 test $0x1,%cl
-48 f7 c1 02 00 00 00 test $0x2,%rcx
+f6 c1 02 test $0x2,%cl
-41 f7 c2 01 00 00 00 test $0x1,%r10d
+41 f6 c2 01 test $0x1,%r10b
-48 f7 c1 04 00 00 00 test $0x4,%rcx
+f6 c1 04 test $0x4,%cl
-48 f7 c1 08 00 00 00 test $0x8,%rcx
+f6 c1 08 test $0x8,%cl
Linus further notes:
"There are no stalls from using 8-bit instruction forms.
Now, changing from 64-bit or 32-bit 'test' instructions to 8-bit ones
*could* cause problems if it ends up having forwarding issues, so that
instead of just forwarding the result, you end up having to wait for
it to be stable in the L1 cache (or possibly the register file). The
forwarding from the store buffer is simplest and most reliable if the
read is done at the exact same address and the exact same size as the
write that gets forwarded.
But that's true only if:
(a) the write was very recent and is still in the write queue. I'm
not sure that's the case here anyway.
(b) on at least most Intel microarchitectures, you have to test a
different byte than the lowest one (so forwarding a 64-bit write
to a 8-bit read ends up working fine, as long as the 8-bit read
is of the low 8 bits of the written data).
A very similar issue *might* show up for registers too, not just
memory writes, if you use 'testb' with a high-byte register (where
instead of forwarding the value from the original producer it needs to
go through the register file and then shifted). But it's mainly a
problem for store buffers.
But afaik, the way Denys changed the test instructions, neither of the
above issues should be true.
The real problem for store buffer forwarding tends to be "write 8
bits, read 32 bits". That can be really surprisingly expensive,
because the read ends up having to wait until the write has hit the
cacheline, and we might talk tens of cycles of latency here. But
"write 32 bits, read the low 8 bits" *should* be fast on pretty much
all x86 chips, afaik."
Signed-off-by: Denys Vlasenko <dvlasenk@redhat.com>
Acked-by: Andy Lutomirski <luto@amacapital.net>
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Will Drewry <wad@chromium.org>
Link: http://lkml.kernel.org/r/1425675332-31576-1-git-send-email-dvlasenk@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-03-07 04:55:32 +08:00
|
|
|
testb $0x4, %cl /* is it the done indicator? */
|
2005-06-26 05:58:02 +08:00
|
|
|
jz 2f
|
|
|
|
jmp 3f
|
|
|
|
2:
|
x86/asm: Optimize unnecessarily wide TEST instructions
By the nature of the TEST operation, it is often possible to test
a narrower part of the operand:
"testl $3, mem" -> "testb $3, mem",
"testq $3, %rcx" -> "testb $3, %cl"
This results in shorter instructions, because the TEST instruction
has no sign-entending byte-immediate forms unlike other ALU ops.
Note that this change does not create any LCP (Length-Changing Prefix)
stalls, which happen when adding a 0x66 prefix, which happens when
16-bit immediates are used, which changes such TEST instructions:
[test_opcode] [modrm] [imm32]
to:
[0x66] [test_opcode] [modrm] [imm16]
where [imm16] has a *different length* now: 2 bytes instead of 4.
This confuses the decoder and slows down execution.
REX prefixes were carefully designed to almost never hit this case:
adding REX prefix does not change instruction length except MOVABS
and MOV [addr],RAX instruction.
This patch does not add instructions which would use a 0x66 prefix,
code changes in assembly are:
-48 f7 07 01 00 00 00 testq $0x1,(%rdi)
+f6 07 01 testb $0x1,(%rdi)
-48 f7 c1 01 00 00 00 test $0x1,%rcx
+f6 c1 01 test $0x1,%cl
-48 f7 c1 02 00 00 00 test $0x2,%rcx
+f6 c1 02 test $0x2,%cl
-41 f7 c2 01 00 00 00 test $0x1,%r10d
+41 f6 c2 01 test $0x1,%r10b
-48 f7 c1 04 00 00 00 test $0x4,%rcx
+f6 c1 04 test $0x4,%cl
-48 f7 c1 08 00 00 00 test $0x8,%rcx
+f6 c1 08 test $0x8,%cl
Linus further notes:
"There are no stalls from using 8-bit instruction forms.
Now, changing from 64-bit or 32-bit 'test' instructions to 8-bit ones
*could* cause problems if it ends up having forwarding issues, so that
instead of just forwarding the result, you end up having to wait for
it to be stable in the L1 cache (or possibly the register file). The
forwarding from the store buffer is simplest and most reliable if the
read is done at the exact same address and the exact same size as the
write that gets forwarded.
But that's true only if:
(a) the write was very recent and is still in the write queue. I'm
not sure that's the case here anyway.
(b) on at least most Intel microarchitectures, you have to test a
different byte than the lowest one (so forwarding a 64-bit write
to a 8-bit read ends up working fine, as long as the 8-bit read
is of the low 8 bits of the written data).
A very similar issue *might* show up for registers too, not just
memory writes, if you use 'testb' with a high-byte register (where
instead of forwarding the value from the original producer it needs to
go through the register file and then shifted). But it's mainly a
problem for store buffers.
But afaik, the way Denys changed the test instructions, neither of the
above issues should be true.
The real problem for store buffer forwarding tends to be "write 8
bits, read 32 bits". That can be really surprisingly expensive,
because the read ends up having to wait until the write has hit the
cacheline, and we might talk tens of cycles of latency here. But
"write 32 bits, read the low 8 bits" *should* be fast on pretty much
all x86 chips, afaik."
Signed-off-by: Denys Vlasenko <dvlasenk@redhat.com>
Acked-by: Andy Lutomirski <luto@amacapital.net>
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: H. Peter Anvin <hpa@linux.intel.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Kees Cook <keescook@chromium.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Will Drewry <wad@chromium.org>
Link: http://lkml.kernel.org/r/1425675332-31576-1-git-send-email-dvlasenk@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-03-07 04:55:32 +08:00
|
|
|
testb $0x8, %cl /* is it the source indicator? */
|
2005-06-26 05:58:02 +08:00
|
|
|
jz 0b /* Ignore it otherwise */
|
|
|
|
movq %rcx, %rsi /* For ever source page do a copy */
|
|
|
|
andq $0xfffffffffffff000, %rsi
|
|
|
|
|
2009-03-10 10:57:16 +08:00
|
|
|
movq %rdi, %rdx
|
|
|
|
movq %rsi, %rax
|
|
|
|
|
|
|
|
movq %r10, %rdi
|
2015-04-01 01:00:10 +08:00
|
|
|
movl $512, %ecx
|
2005-06-26 05:58:02 +08:00
|
|
|
rep ; movsq
|
|
|
|
|
2009-03-10 10:57:16 +08:00
|
|
|
movq %rax, %rdi
|
|
|
|
movq %rdx, %rsi
|
2015-04-01 01:00:10 +08:00
|
|
|
movl $512, %ecx
|
2009-03-10 10:57:16 +08:00
|
|
|
rep ; movsq
|
2005-06-26 05:58:02 +08:00
|
|
|
|
2009-03-10 10:57:16 +08:00
|
|
|
movq %rdx, %rdi
|
|
|
|
movq %r10, %rsi
|
2015-04-01 01:00:10 +08:00
|
|
|
movl $512, %ecx
|
2009-03-10 10:57:16 +08:00
|
|
|
rep ; movsq
|
2005-06-26 05:58:02 +08:00
|
|
|
|
2009-03-10 10:57:16 +08:00
|
|
|
lea PAGE_SIZE(%rax), %rsi
|
|
|
|
jmp 0b
|
|
|
|
3:
|
2005-06-26 05:58:02 +08:00
|
|
|
ret
|
2009-03-10 10:57:16 +08:00
|
|
|
|
|
|
|
.globl kexec_control_code_size
|
|
|
|
.set kexec_control_code_size, . - relocate_kernel
|