x86/sgx: Initialize metadata for Enclave Page Cache (EPC) sections

Although carved out of normal DRAM, enclave memory is marked in the
system memory map as reserved and is not managed by the core mm.  There
may be several regions spread across the system.  Each contiguous region
is called an Enclave Page Cache (EPC) section.  EPC sections are
enumerated via CPUID

Enclave pages can only be accessed when they are mapped as part of an
enclave, by a hardware thread running inside the enclave.

Parse CPUID data, create metadata for EPC pages and populate a simple
EPC page allocator.  Although much smaller, ‘struct sgx_epc_page’
metadata is the SGX analog of the core mm ‘struct page’.

Similar to how the core mm’s page->flags encode zone and NUMA
information, embed the EPC section index to the first eight bits of
sgx_epc_page->desc.  This allows a quick reverse lookup from EPC page to
EPC section.  Existing client hardware supports only a single section,
while upcoming server hardware will support at most eight sections.
Thus, eight bits should be enough for long term needs.

Signed-off-by: Sean Christopherson <sean.j.christopherson@intel.com>
Co-developed-by: Serge Ayoun <serge.ayoun@intel.com>
Signed-off-by: Serge Ayoun <serge.ayoun@intel.com>
Co-developed-by: Jarkko Sakkinen <jarkko@kernel.org>
Signed-off-by: Jarkko Sakkinen <jarkko@kernel.org>
Signed-off-by: Borislav Petkov <bp@suse.de>
Acked-by: Jethro Beekman <jethro@fortanix.com>
Link: https://lkml.kernel.org/r/20201112220135.165028-6-jarkko@kernel.org

diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index f6946b8..618d1aa 100644 (file)
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -1930,6 +1930,23 @@ config X86_INTEL_TSX_MODE_AUTO
          side channel attacks- equals the tsx=auto command line parameter.
 endchoice
 
+config X86_SGX
+       bool "Software Guard eXtensions (SGX)"
+       depends on X86_64 && CPU_SUP_INTEL
+       depends on CRYPTO=y
+       depends on CRYPTO_SHA256=y
+       select SRCU
+       select MMU_NOTIFIER
+       help
+         Intel(R) Software Guard eXtensions (SGX) is a set of CPU instructions
+         that can be used by applications to set aside private regions of code
+         and data, referred to as enclaves. An enclave's private memory can
+         only be accessed by code running within the enclave. Accesses from
+         outside the enclave, including other enclaves, are disallowed by
+         hardware.
+
+         If unsure, say N.
+
 config EFI
        bool "EFI runtime service support"
        depends on ACPI

diff --git a/arch/x86/kernel/cpu/Makefile b/arch/x86/kernel/cpu/Makefile
index 93792b4..637b499 100644 (file)
--- a/arch/x86/kernel/cpu/Makefile
+++ b/arch/x86/kernel/cpu/Makefile
@@ -48,6 +48,7 @@ obj-$(CONFIG_X86_MCE)                 += mce/
 obj-$(CONFIG_MTRR)                     += mtrr/
 obj-$(CONFIG_MICROCODE)                        += microcode/
 obj-$(CONFIG_X86_CPU_RESCTRL)          += resctrl/
+obj-$(CONFIG_X86_SGX)                  += sgx/
 
 obj-$(CONFIG_X86_LOCAL_APIC)           += perfctr-watchdog.o
 

diff --git a/arch/x86/kernel/cpu/sgx/Makefile b/arch/x86/kernel/cpu/sgx/Makefile
new file mode 100644 (file)
index 0000000..79510ce
--- /dev/null
+++ b/arch/x86/kernel/cpu/sgx/Makefile
@@ -0,0 +1,2 @@
+obj-y += \
+       main.o

diff --git a/arch/x86/kernel/cpu/sgx/main.c b/arch/x86/kernel/cpu/sgx/main.c
new file mode 100644 (file)
index 0000000..187a237
--- /dev/null
+++ b/arch/x86/kernel/cpu/sgx/main.c
@@ -0,0 +1,190 @@
+// SPDX-License-Identifier: GPL-2.0
+/*  Copyright(c) 2016-20 Intel Corporation. */
+
+#include <linux/freezer.h>
+#include <linux/highmem.h>
+#include <linux/kthread.h>
+#include <linux/pagemap.h>
+#include <linux/ratelimit.h>
+#include <linux/sched/mm.h>
+#include <linux/sched/signal.h>
+#include <linux/slab.h>
+#include "encls.h"
+
+struct sgx_epc_section sgx_epc_sections[SGX_MAX_EPC_SECTIONS];
+static int sgx_nr_epc_sections;
+static struct task_struct *ksgxd_tsk;
+
+/*
+ * Reset dirty EPC pages to uninitialized state. Laundry can be left with SECS
+ * pages whose child pages blocked EREMOVE.
+ */
+static void sgx_sanitize_section(struct sgx_epc_section *section)
+{
+       struct sgx_epc_page *page;
+       LIST_HEAD(dirty);
+       int ret;
+
+       while (!list_empty(&section->laundry_list)) {
+               if (kthread_should_stop())
+                       return;
+
+               spin_lock(&section->lock);
+
+               page = list_first_entry(&section->laundry_list,
+                                       struct sgx_epc_page, list);
+
+               ret = __eremove(sgx_get_epc_virt_addr(page));
+               if (!ret)
+                       list_move(&page->list, &section->page_list);
+               else
+                       list_move_tail(&page->list, &dirty);
+
+               spin_unlock(&section->lock);
+
+               cond_resched();
+       }
+
+       list_splice(&dirty, &section->laundry_list);
+}
+
+static int ksgxd(void *p)
+{
+       int i;
+
+       set_freezable();
+
+       /*
+        * Sanitize pages in order to recover from kexec(). The 2nd pass is
+        * required for SECS pages, whose child pages blocked EREMOVE.
+        */
+       for (i = 0; i < sgx_nr_epc_sections; i++)
+               sgx_sanitize_section(&sgx_epc_sections[i]);
+
+       for (i = 0; i < sgx_nr_epc_sections; i++) {
+               sgx_sanitize_section(&sgx_epc_sections[i]);
+
+               /* Should never happen. */
+               if (!list_empty(&sgx_epc_sections[i].laundry_list))
+                       WARN(1, "EPC section %d has unsanitized pages.\n", i);
+       }
+
+       return 0;
+}
+
+static bool __init sgx_page_reclaimer_init(void)
+{
+       struct task_struct *tsk;
+
+       tsk = kthread_run(ksgxd, NULL, "ksgxd");
+       if (IS_ERR(tsk))
+               return false;
+
+       ksgxd_tsk = tsk;
+
+       return true;
+}
+
+static bool __init sgx_setup_epc_section(u64 phys_addr, u64 size,
+                                        unsigned long index,
+                                        struct sgx_epc_section *section)
+{
+       unsigned long nr_pages = size >> PAGE_SHIFT;
+       unsigned long i;
+
+       section->virt_addr = memremap(phys_addr, size, MEMREMAP_WB);
+       if (!section->virt_addr)
+               return false;
+
+       section->pages = vmalloc(nr_pages * sizeof(struct sgx_epc_page));
+       if (!section->pages) {
+               memunmap(section->virt_addr);
+               return false;
+       }
+
+       section->phys_addr = phys_addr;
+       spin_lock_init(&section->lock);
+       INIT_LIST_HEAD(&section->page_list);
+       INIT_LIST_HEAD(&section->laundry_list);
+
+       for (i = 0; i < nr_pages; i++) {
+               section->pages[i].section = index;
+               list_add_tail(&section->pages[i].list, &section->laundry_list);
+       }
+
+       return true;
+}
+
+/**
+ * A section metric is concatenated in a way that @low bits 12-31 define the
+ * bits 12-31 of the metric and @high bits 0-19 define the bits 32-51 of the
+ * metric.
+ */
+static inline u64 __init sgx_calc_section_metric(u64 low, u64 high)
+{
+       return (low & GENMASK_ULL(31, 12)) +
+              ((high & GENMASK_ULL(19, 0)) << 32);
+}
+
+static bool __init sgx_page_cache_init(void)
+{
+       u32 eax, ebx, ecx, edx, type;
+       u64 pa, size;
+       int i;
+
+       for (i = 0; i < ARRAY_SIZE(sgx_epc_sections); i++) {
+               cpuid_count(SGX_CPUID, i + SGX_CPUID_EPC, &eax, &ebx, &ecx, &edx);
+
+               type = eax & SGX_CPUID_EPC_MASK;
+               if (type == SGX_CPUID_EPC_INVALID)
+                       break;
+
+               if (type != SGX_CPUID_EPC_SECTION) {
+                       pr_err_once("Unknown EPC section type: %u\n", type);
+                       break;
+               }
+
+               pa   = sgx_calc_section_metric(eax, ebx);
+               size = sgx_calc_section_metric(ecx, edx);
+
+               pr_info("EPC section 0x%llx-0x%llx\n", pa, pa + size - 1);
+
+               if (!sgx_setup_epc_section(pa, size, i, &sgx_epc_sections[i])) {
+                       pr_err("No free memory for an EPC section\n");
+                       break;
+               }
+
+               sgx_nr_epc_sections++;
+       }
+
+       if (!sgx_nr_epc_sections) {
+               pr_err("There are zero EPC sections.\n");
+               return false;
+       }
+
+       return true;
+}
+
+static void __init sgx_init(void)
+{
+       int i;
+
+       if (!boot_cpu_has(X86_FEATURE_SGX))
+               return;
+
+       if (!sgx_page_cache_init())
+               return;
+
+       if (!sgx_page_reclaimer_init())
+               goto err_page_cache;
+
+       return;
+
+err_page_cache:
+       for (i = 0; i < sgx_nr_epc_sections; i++) {
+               vfree(sgx_epc_sections[i].pages);
+               memunmap(sgx_epc_sections[i].virt_addr);
+       }
+}
+
+device_initcall(sgx_init);

diff --git a/arch/x86/kernel/cpu/sgx/sgx.h b/arch/x86/kernel/cpu/sgx/sgx.h
new file mode 100644 (file)
index 0000000..02afa84
--- /dev/null
+++ b/arch/x86/kernel/cpu/sgx/sgx.h
@@ -0,0 +1,60 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _X86_SGX_H
+#define _X86_SGX_H
+
+#include <linux/bitops.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/rwsem.h>
+#include <linux/types.h>
+#include <asm/asm.h>
+#include "arch.h"
+
+#undef pr_fmt
+#define pr_fmt(fmt) "sgx: " fmt
+
+#define SGX_MAX_EPC_SECTIONS           8
+
+struct sgx_epc_page {
+       unsigned int section;
+       struct list_head list;
+};
+
+/*
+ * The firmware can define multiple chunks of EPC to the different areas of the
+ * physical memory e.g. for memory areas of the each node. This structure is
+ * used to store EPC pages for one EPC section and virtual memory area where
+ * the pages have been mapped.
+ */
+struct sgx_epc_section {
+       unsigned long phys_addr;
+       void *virt_addr;
+       struct list_head page_list;
+       struct list_head laundry_list;
+       struct sgx_epc_page *pages;
+       spinlock_t lock;
+};
+
+extern struct sgx_epc_section sgx_epc_sections[SGX_MAX_EPC_SECTIONS];
+
+static inline unsigned long sgx_get_epc_phys_addr(struct sgx_epc_page *page)
+{
+       struct sgx_epc_section *section = &sgx_epc_sections[page->section];
+       unsigned long index;
+
+       index = ((unsigned long)page - (unsigned long)section->pages) / sizeof(*page);
+
+       return section->phys_addr + index * PAGE_SIZE;
+}
+
+static inline void *sgx_get_epc_virt_addr(struct sgx_epc_page *page)
+{
+       struct sgx_epc_section *section = &sgx_epc_sections[page->section];
+       unsigned long index;
+
+       index = ((unsigned long)page - (unsigned long)section->pages) / sizeof(*page);
+
+       return section->virt_addr + index * PAGE_SIZE;
+}
+
+#endif /* _X86_SGX_H */