Commit-ID:  606b21d4a6498c23632a4693c81b7b24feedd038
Gitweb:     https://git.kernel.org/tip/606b21d4a6498c23632a4693c81b7b24feedd038
Author:     Tom Lendacky <[email protected]>
AuthorDate: Fri, 20 Oct 2017 09:30:55 -0500
Committer:  Thomas Gleixner <[email protected]>
CommitDate: Tue, 7 Nov 2017 15:35:59 +0100

x86/io: Unroll string I/O when SEV is active

Secure Encrypted Virtualization (SEV) does not support string I/O, so
unroll the string I/O operation into a loop operating on one element at
a time.

[ tglx: Gave the static key a real name instead of the obscure __sev ]

Signed-off-by: Tom Lendacky <[email protected]>
Signed-off-by: Brijesh Singh <[email protected]>
Signed-off-by: Thomas Gleixner <[email protected]>
Reviewed-by: Borislav Petkov <[email protected]>
Tested-by: Borislav Petkov <[email protected]>
Cc: Andy Shevchenko <[email protected]>
Cc: Arnd Bergmann <[email protected]>
Cc: [email protected]
Cc: David Laight <[email protected]>
Cc: Borislav Petkov <[email protected]>
Link: https://lkml.kernel.org/r/[email protected]

---
 arch/x86/include/asm/io.h | 43 +++++++++++++++++++++++++++++++++++++++----
 arch/x86/mm/mem_encrypt.c |  8 ++++++++
 2 files changed, 47 insertions(+), 4 deletions(-)

diff --git a/arch/x86/include/asm/io.h b/arch/x86/include/asm/io.h
index 11398d5..93ae8ae 100644
--- a/arch/x86/include/asm/io.h
+++ b/arch/x86/include/asm/io.h
@@ -266,6 +266,21 @@ static inline void slow_down_io(void)
 
 #endif
 
+#ifdef CONFIG_AMD_MEM_ENCRYPT
+#include <linux/jump_label.h>
+
+extern struct static_key_false sev_enable_key;
+static inline bool sev_key_active(void)
+{
+       return static_branch_unlikely(&sev_enable_key);
+}
+
+#else /* !CONFIG_AMD_MEM_ENCRYPT */
+
+static inline bool sev_key_active(void) { return false; }
+
+#endif /* CONFIG_AMD_MEM_ENCRYPT */
+
 #define BUILDIO(bwl, bw, type)                                         \
 static inline void out##bwl(unsigned type value, int port)             \
 {                                                                      \
@@ -296,14 +311,34 @@ static inline unsigned type in##bwl##_p(int port)         
        \
                                                                        \
 static inline void outs##bwl(int port, const void *addr, unsigned long count) \
 {                                                                      \
-       asm volatile("rep; outs" #bwl                                   \
-                    : "+S"(addr), "+c"(count) : "d"(port) : "memory"); \
+       if (sev_key_active()) {                                         \
+               unsigned type *value = (unsigned type *)addr;           \
+               while (count) {                                         \
+                       out##bwl(*value, port);                         \
+                       value++;                                        \
+                       count--;                                        \
+               }                                                       \
+       } else {                                                        \
+               asm volatile("rep; outs" #bwl                           \
+                            : "+S"(addr), "+c"(count)                  \
+                            : "d"(port) : "memory");                   \
+       }                                                               \
 }                                                                      \
                                                                        \
 static inline void ins##bwl(int port, void *addr, unsigned long count) \
 {                                                                      \
-       asm volatile("rep; ins" #bwl                                    \
-                    : "+D"(addr), "+c"(count) : "d"(port) : "memory"); \
+       if (sev_key_active()) {                                         \
+               unsigned type *value = (unsigned type *)addr;           \
+               while (count) {                                         \
+                       *value = in##bwl(port);                         \
+                       value++;                                        \
+                       count--;                                        \
+               }                                                       \
+       } else {                                                        \
+               asm volatile("rep; ins" #bwl                            \
+                            : "+D"(addr), "+c"(count)                  \
+                            : "d"(port) : "memory");                   \
+       }                                                               \
 }
 
 BUILDIO(b, b, char)
diff --git a/arch/x86/mm/mem_encrypt.c b/arch/x86/mm/mem_encrypt.c
index fd9c7bb..d29b783 100644
--- a/arch/x86/mm/mem_encrypt.c
+++ b/arch/x86/mm/mem_encrypt.c
@@ -41,6 +41,8 @@ static char sme_cmdline_off[] __initdata = "off";
  */
 u64 sme_me_mask __section(.data) = 0;
 EXPORT_SYMBOL_GPL(sme_me_mask);
+DEFINE_STATIC_KEY_FALSE(sev_enable_key);
+EXPORT_SYMBOL_GPL(sev_enable_key);
 
 static bool sev_enabled __section(.data);
 
@@ -313,6 +315,12 @@ void __init mem_encrypt_init(void)
        if (sev_active())
                dma_ops = &sev_dma_ops;
 
+       /*
+        * With SEV, we need to unroll the rep string I/O instructions.
+        */
+       if (sev_active())
+               static_branch_enable(&sev_enable_key);
+
        pr_info("AMD %s active\n",
                sev_active() ? "Secure Encrypted Virtualization (SEV)"
                             : "Secure Memory Encryption (SME)");

Reply via email to