x86/sgx: Hook arch_memory_failure() into mainline code

Add a call inside memory_failure() to call the arch specific code
to check if the address is an SGX EPC page and handle it.

Note the SGX EPC pages do not have a "struct page" entry, so the hook
goes in at the same point as the device mapping hook.

Pull the call to acquire the mutex earlier so the SGX errors are also
protected.

Make set_mce_nospec() skip SGX pages when trying to adjust
the 1:1 map.

Signed-off-by: Tony Luck <tony.luck@intel.com>
Signed-off-by: Dave Hansen <dave.hansen@linux.intel.com>
Reviewed-by: Jarkko Sakkinen <jarkko@kernel.org>
Reviewed-by: Naoya Horiguchi <naoya.horiguchi@nec.com>
Tested-by: Reinette Chatre <reinette.chatre@intel.com>
Link: https://lkml.kernel.org/r/20211026220050.697075-6-tony.luck@intel.com

diff --git a/arch/x86/include/asm/processor.h b/arch/x86/include/asm/processor.h
index 355d38c0cf60604c849a68ba8242f3767f61638a..2c5f12ae7d0427988708922ba79df05023281ee0 100644 (file)
--- a/arch/x86/include/asm/processor.h
+++ b/arch/x86/include/asm/processor.h
@@ -855,4 +855,12 @@ enum mds_mitigations {
        MDS_MITIGATION_VMWERV,
 };
 
+#ifdef CONFIG_X86_SGX
+int arch_memory_failure(unsigned long pfn, int flags);
+#define arch_memory_failure arch_memory_failure
+
+bool arch_is_platform_page(u64 paddr);
+#define arch_is_platform_page arch_is_platform_page
+#endif
+
 #endif /* _ASM_X86_PROCESSOR_H */

diff --git a/arch/x86/include/asm/set_memory.h b/arch/x86/include/asm/set_memory.h
index 872617542bbc0039cf4d2bc327d76d5e9e7fac6b..ff0f2d90338a192ce0bc4f65f108299147804496 100644 (file)
--- a/arch/x86/include/asm/set_memory.h
+++ b/arch/x86/include/asm/set_memory.h
@@ -2,6 +2,7 @@
 #ifndef _ASM_X86_SET_MEMORY_H
 #define _ASM_X86_SET_MEMORY_H
 
+#include <linux/mm.h>
 #include <asm/page.h>
 #include <asm-generic/set_memory.h>
 
@@ -99,6 +100,9 @@ static inline int set_mce_nospec(unsigned long pfn, bool unmap)
        unsigned long decoy_addr;
        int rc;
 
+       /* SGX pages are not in the 1:1 map */
+       if (arch_is_platform_page(pfn << PAGE_SHIFT))
+               return 0;
        /*
         * We would like to just call:
         *      set_memory_XX((unsigned long)pfn_to_kaddr(pfn), 1);

diff --git a/include/linux/mm.h b/include/linux/mm.h
index a7e4a9e7d807a39bc549bcfc7238e03c4e7237bd..57f1aa2a33b6dff70a2104795d4403707ea70cb0 100644 (file)
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -3231,6 +3231,19 @@ extern void shake_page(struct page *p);
 extern atomic_long_t num_poisoned_pages __read_mostly;
 extern int soft_offline_page(unsigned long pfn, int flags);
 
+#ifndef arch_memory_failure
+static inline int arch_memory_failure(unsigned long pfn, int flags)
+{
+       return -ENXIO;
+}
+#endif
+
+#ifndef arch_is_platform_page
+static inline bool arch_is_platform_page(u64 paddr)
+{
+       return false;
+}
+#endif
 
 /*
  * Error handlers for various types of pages.

diff --git a/mm/memory-failure.c b/mm/memory-failure.c
index 07c875fdeaf0ca82e86bb8db8b32164a2d4357e0..fddee33bc6cbf3f15b265fedc5d174a475e771ae 100644 (file)
--- a/mm/memory-failure.c
+++ b/mm/memory-failure.c
@@ -1651,21 +1651,28 @@ int memory_failure(unsigned long pfn, int flags)
        if (!sysctl_memory_failure_recovery)
                panic("Memory failure on page %lx", pfn);
 
+       mutex_lock(&mf_mutex);
+
        p = pfn_to_online_page(pfn);
        if (!p) {
+               res = arch_memory_failure(pfn, flags);
+               if (res == 0)
+                       goto unlock_mutex;
+
                if (pfn_valid(pfn)) {
                        pgmap = get_dev_pagemap(pfn, NULL);
-                       if (pgmap)
-                               return memory_failure_dev_pagemap(pfn, flags,
-                                                                 pgmap);
+                       if (pgmap) {
+                               res = memory_failure_dev_pagemap(pfn, flags,
+                                                                pgmap);
+                               goto unlock_mutex;
+                       }
                }
                pr_err("Memory failure: %#lx: memory outside kernel control\n",
                        pfn);
-               return -ENXIO;
+               res = -ENXIO;
+               goto unlock_mutex;
        }
 
-       mutex_lock(&mf_mutex);
-
 try_again:
        if (PageHuge(p)) {
                res = memory_failure_hugetlb(pfn, flags);