Intel SGX foundations
Subsystems (11)
Jarkko Sakkinen
maintainerv41 cover Intel SGX foundations
Overview
========
Intel(R) SGX is new hardware functionality that can be used by applications to populate protected regions of user code and data called enclaves. Once activated, the new hardware protects enclave code and data from outside access and modification.
SGX implementations have existed on desktop processors for several years. The upcoming 3rd Generation Intel Xeon Scalable Platform, code-named “Ice Lake” will also support SGX[1].
Use Cases
=========
Enclaves provide a place to store secrets and process data with those secrets. SGX has been used, for example, to decrypt video without exposing the decryption keys to nosy debuggers that might be used to subvert DRM. Software has generally been rewritten specifically to run in enclaves, but there are also projects that try to run limited unmodified software in enclaves[2].
SGX hardware is available in public clouds today. But, anyone wishing to use it must use a modified distribution or side-load SGX support[3].
Hardware Implementation
=======================
New memory controller hardware encrypts data transparently before leaving the processor package. The randomly-generated encryption key has a lifetime of exactly one power cycle. This mitigates attacks originating outside the processor, like snooping DIMM traffic.
Important Kernel Touch Points
=============================
Although statically carved out of normal DRAM, enclave memory can not be accessed or managed directly by the kernel and is marked by the firmware as “Reserved”. As a result, SGX support contains simple but analogous functionality to the core mm such as a page allocator and reclaim.
Entering and exiting enclaves is tricky business. Enclaves are restricted from making system calls or taking interrupts directly. The enclave will exit out to userspace before things like this can happen. A new vDSO exception mechanism is introduced to help smooth over some of the architectural rough edges and make the job of userspace easier.
This implementation is picky and will decline to work on hardware which is locked to Intel’s root of trust.
1. https://newsroom.intel.com/news-releases/intel-xeon-scalable-platform-built-most-sensitive-workloads/
2. https://grapheneproject.io/
3. https://docs.microsoft.com/en-us/azure/confidential-computing/quick-create-portal
Other
=====
Sean Christopherson is a major contributor to this series. However, he has left Intel and his @intel.com address will soon be bouncing. He does not have a email he wants us to substitute or put in .mailmap for now. To avoid subjecting everyone to bounces, we have commented out his tag lines in the commit messages.
Originally the code was based on early prototyping work of Suresh S.
This patch set has been rebased on top of tip tree commit c3c30db1b191bb1640a08bbcc593c212affcab75.
v40 (2020-10-20):
* Change copyright years to 2016-2020 in the all files added.
https://lore.kernel.org/linux-sgx/[email protected]/
* Remove dual licensing and use GPL 2.0 unconditionally.
https://lore.kernel.org/linux-sgx/[email protected]/
* Remove platform capabilities checks from sgx_validate_secs(), as they are validated together with the SIGSTRUCT capabilities in sgx_ioc_enclave_init().
https://lore.kernel.org/linux-sgx/[email protected]/
* During the migration from radix_tree to xarray, the locks went missing from sgx_encl_may_map(). Fix this by iterating with the enclave lock and xarray lock held.
https://lore.kernel.org/linux-sgx/[email protected]/
* Verify in the #PF handler that the faulted page has equal or higher build time permissions than the VMA permissions (i.e. the subset of {VM_READ, VM_WRITE, VM_EXECUTE} in vma->vm_flags). Trigger a bus error, if this not the case. By doing this, mmap() and mprotect() can be allowed to map an address range, which has unpopulated pages, because the required invariant will be checked before new pages are inserted to the process address space.
* In the vDSO, do not save RBX before validating the reserved area of the struct sgx_enclave_run.
https://lore.kernel.org/linux-sgx/[email protected]/
* Increase the reserved area to 256 bytes in struct sgx_enclave_run as there needs to be some space for expansion given the evolution of microarchitectures, the fact that there can be only one vDSO and possible future extensions.
https://lore.kernel.org/linux-sgx/[email protected]/
* Change Copyright comments from '//' to '/* ... */'.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix the error fallback path in the SGX vDSO. RAX was not popped in the error path.
https://lore.kernel.org/linux-sgx/[email protected]/
* Move mm list management, backing storage and refcounting code to “x86/sgx: Add a page reclaimer”, as they are only needed by the page reclaimer. Finally, change the patch position to be the very last after the kselftest, so that the whole patch set can be tested easily with and without the reclaimer.
* Move sgx_xsave_size_tbl code from “x86/sgx: Add SGX enclave driver” to “x86/sgx: Add SGX_IOC_ENCLAVE_CREATE”. Comment the code and use XFEATURE_YMM and XFEATURE_MAX as limits for the features.
* Fix bug sgx_sanitize_section() that pages left dirty were not returned back, which could lead to a memory leak. Rename unsanitized_page_list as more intuitive and shorter laundry_list and document the function itself and the call site.
* Use vmalloc() to allocate an array of struct sgx_epc_page’s for struct sgx_epc_section, in effect removing the need to store addresses inside the page structures. This removes the artificial limit of 8 sections. The section array is still statically allocated but now it is trivial to increase its size later on.
* Rest of the changes are documented in patch change logs as this is preferred way for the x86 tree.
v39 (2020-10-03):
* A new GIT tree location.
git://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-sgx.git
* Return -ERESTARTSYS instead of -EINTR in SGX_IOC_ENCLAVE_ADD_PAGES.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Do not initialize 'encl_size' in sgx_encl_create before
sgx_validate_secs() is called.
https://lore.kernel.org/linux-sgx/[email protected]/
* Revert 'count' back to struct sgx_enclave_add_pages, move the check of
-EIO to sgx_ioc_enclave_pages() instead of being buried in subfunctions.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix documentation for the 'encl' parameter in sgx_ioc_enclave_create(),
sgx_ioc_enclave_init() and sgx_ioc_enclave_provision().
https://lore.kernel.org/linux-sgx/[email protected]/
* Refine sgx_ioc_enclave_create() kdoc to better describe the meaning and
purpose of SECS validation done by sgx_validate_secs().
https://lore.kernel.org/linux-sgx/[email protected]/
* Improve documentation sgx_ioc_enclave_add_pages() on IO failures.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix a bug in __sgx_encl_add_page(). When get_user_pages() fails, we must
return -EFAULT instead of mistakenly returning the page count.
Reported by Haitao Huang.
* Rewrite the commit message for vm_ops->mprotect() (courtesy of Dave Hansen)
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix ptrace support coding style issues.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix the documentation.
https://lore.kernel.org/linux-sgx/[email protected]/
* Always write MSRs for the public key before EINIT.
https://lore.kernel.org/linux-sgx/[email protected]/
* Categorically disabled enclaves from noexec partitions.
https://lore.kernel.org/linux-sgx/[email protected]/
* Properly document the EWB flow, i.e. why there is three trials for EWB.
https://lore.kernel.org/linux-sgx/[email protected]/
* Add kdoc about batch processing to sgx_reclaim_pages().
https://lore.kernel.org/linux-sgx/[email protected]/
https://lore.kernel.org/linux-mm/[email protected]/
* Documentation fixes.
https://lore.kernel.org/linux-sgx/[email protected]/T/#me637011aba9f45698eba88ff195452c0491c07fe
* SGX vDSO clean ups.
https://lore.kernel.org/linux-sgx/[email protected]/T/#ma2204bba8d8e8a09bf9164fc1bb5c55813997b4a
* Add the commit message from "x86/vdso: Add support for exception fixup in vDSO functions" to Documentation/x86/sgx.rst
https://lore.kernel.org/linux-sgx/[email protected]/
* Update correct attributes variable when allowing provisioning.
https://lore.kernel.org/linux-sgx/[email protected]/T/#t
* Remove sgx_exception and put its fields to sgx_exception.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Remove 'exit_reason' and put EEXIT to 'self' field of sgx_enclave_run.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Refine clarity of the field names in struct sgx_enclave_run and vsgx.S, and rewrite kdoc.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Fix memory validation in vsgx.S. The reserved areas was not zero validated,
which causes unnecessary risk for memory corruption bugs. In effect, 'flags'
field can be removed from struct sgx_enclave_run.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Reduce the size of sgx_enclave_run from 256 bytes to 64 bytes, i.e. size of
a cache line. This leave 24 bytes of free space to waste in future.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Verify atttributes, miscsselect and xfrm also in EINIT against SIGSTRUCT set
limits.
https://lore.kernel.org/linux-sgx/[email protected]/
* Use plain lfence instead of retpoline in the vDSO because retpoline has
the potential to cause forward compatibility issues with the future
microarchitecture features. One such in already sight is CET-SS.
https://lore.kernel.org/linux-sgx/[email protected]/T/#ma65748158e2b967dbc1d9ac3b214a1415066d61c
v38:
* Fast iteration because I had email server issues with v37. Using temporary SMTP for this (mail.kapsi.fi).
* Return -EINTR when no data is processed, just like read().
https://patchwork.kernel.org/patch/11773941/
* Remove cruft from SGX_IOC_ENCLAVE_ADD_PAGES and fix the return value.
https://lore.kernel.org/linux-sgx/[email protected]/T/#mc643ef2ab477f5f7aa5d463d883d1308eb44d6f1
v37:
* Remove MODULE_*().
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix mmap() type check.
https://lore.kernel.org/linux-sgx/20200827152051.GB22351@sjchrist-ice/
* Fix ioctl-number.txt.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix SPDX identifier in arch/x86/include/uapi/asm/sgx.h
https://lore.kernel.org/linux-sgx/[email protected]/
* Consistently document "@encl: an enclave pointer".
https://lore.kernel.org/linux-sgx/[email protected]/
* Renamed SGX_IOC_ENCLAVE_SET_ATTRIBUTE as SGX_IOC_ENCLAVE_PROVISION and
cleaned up associated code. Also fixed issues of code introduced too
early that were caused by the split. Now it should be more streamlined.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fixed signed integer shift overflow:
https://github.com/intel/linux-sgx-driver/pull/16/commits d27ca6071b2b28e2e789d265eda796dd9fc65a64
* Fixed off-by-one error in a size calculation:
https://github.com/intel/SGXDataCenterAttestationPrimitives/commit/e44cc238becf584cc079aef40b557c6af9a03f38
* Rework vDSO API with a context structure for IO data.
https://lore.kernel.org/linux-sgx/[email protected]/
* Refined commentary about retry-loop with ENCLS[EINIT] based on Sean's response.
https://lore.kernel.org/linux-sgx/[email protected]/
* Return positive number from SGX_IOC_ENCLAVE_ADD_PAGES indicating the
number of pages processed and set a fixed 1MB limit for length. In addition,
on interrupt, return 0 and number of processed pages instead of -EINTR.
https://lore.kernel.org/linux-sgx/[email protected]/
v36:
* Make a self-contained mprotect() handler.
* Move from radix_tree to xarray, which is more modern and robust data structure for managing large sparse arrays. Rename encl->page_tree as encl->page_array.
v35:
* Add missing SGX_ENCL_DEAD check to sgx_ioctl().
v34:
* Remove SGX_ENCL_DEAD checks from ioctl.c, as the file is open while executing an ioctl.
* Split driver patch into base patch and one patch for each ioctl.
* Move encl->flags check to the beginning of each ioctl. Return consistently -EINVAL if they don't match the expected values. Before, sometimes -EFAULT was returned instead of -EINVAL.
* Rename vm_ops->may_mprotect as vm_ops->mprotect() and move the call right before call to mprotect_fixup().
v33:
* Rebased to v5.8-rc1. Given the core changes (mmap_lock and #DB handling), it made sense to update the series.
* Refined documentation about how remote attestation is done in SGX.
v32:
* v31 contained not fully cleaned up main.c after merger of main.c and reclaim.c. Fixed in this version.
* Rebased to v5.7. Forgot to do this for v31.
v31:
* Unset SGX_ENCL_IOCTL in the error path of checking encl->flags in order to prevent leaving it set and thus block any further ioctl calls.
* Added missing cleanup_srcu_struct() call to sgx_encl_release().
* Take encl->lock in sgx_encl_add_page() in order to prevent races with the page reclaimer.
* Fix a use-after-free bug from the page reclaimer. Call kref_put() for encl->refcount only after putting enclave page back to the active page list because it could be the last ref to the enclave.
* Filter any CPU disallowed values from sigstruct->vendor SGX_IOC_ENCLAVE_INIT.
* Use bits 0-7 of page descriptor for the EPC section index. This should be enough for long term needs.
* Refined naming for functions that allocate and free EPC pages to be more sound and consistent.
* Merge main.c and reclaim.c into one.
v30:
Bunch of tags added. No actual code changes.
v29:
* The selftest has been moved to selftests/sgx. Because SGX is an execution environment of its own, it really isn't a great fit with more "standard" x86 tests.
The RSA key is now generated on fly and the whole signing process has been made as part of the enclave loader instead of signing the enclave during the compilation time.
Finally, the enclave loader loads now the test enclave directly from its ELF file, which means that ELF file does not need to be coverted as raw binary during the build process.
* Version the mm_list instead of using on synchronize_mm() when adding new entries. We hold the write lock for the mm_struct, and dup_mm() can thus deadlock with the page reclaimer, which could hold the lock for the old mm_struct.
* Disallow mmap(PROT_NONE) from /dev/sgx. Any mapping (e.g. anonymous) can be used to reserve the address range. Now /dev/sgx supports only opaque mappings to the (initialized) enclave data.
* Make the vDSO callable directly from C by preserving RBX and taking leaf from RCX.
v28:
* Documented to Documentation/x86/sgx.rst how the kernel manages the enclave ownership.
* Removed non-LC flow from sgx_einit().
* Removed struct sgx_einittoken since only the size of the corresponding microarchitectural structure is used in the series ATM.
v27:
* Disallow RIE processes to use enclaves as there could a permission conflict between VMA and enclave permissions.
* In the documentation, replace "grep /proc/cpuinfo" with "grep sgx /proc/cpuinfo".
v26:
* Fixed the commit author in "x86/sgx: Linux Enclave Driver", which was changed in v25 by mistake.
* Addressed a bunch of grammar mistakes in sgx.rst (thanks Randy once again for such a detailed feedback).
* Added back the MAINTAINERS update commit, which was mistakenly removed in v25.
* EREMOVE's for SECS cannot be done while sanitizing an EPC section. The CPU does not allow to remove a SECS page before all of its children have been removed, and a child page can be in some other section than the one currently being processed. Thus, removed special SECS processing from sgx_sanitize_page() and instead put sections through it twice. In the 2nd round the lists should only contain SECS pages.
v25:
* Fix a double-free issue when SGX_IOC_ENCLAVE_ADD_PAGES
fails on executing ENCLS[EADD]. The rollback path executed radix_tree_delete() on the same address twice when this happened.
* Return -EINTR instead of -ERESTARTSYS in SGX_IOC_ENCLAVE_ADD_PAGES when a signal is pending.
* As requested by Borislav, move the CPUID 0x12 features to their own word in cpufeatures.
* Sean fixed a bug from sgx_reclaimer_write() where sgx_encl_put_backing() was called with an uninitialized pointer when sgx_encl_get_backing() fails.
* Migrated /dev/sgx/* to misc. This is future-proof as struct miscdevice has 'groups' for setting up sysfs attributes for the device.
* Use device_initcall instead of subsys_initcall so that misc_class is initialized before SGX is initialized.
* Return -EACCES in SGX_IOC_ENCLAVE_INIT when caller tries to select enclave attributes that we the kernel does not allow it to set instead of -EINVAL.
* Unless SGX public key MSRs are writable always deny the feature from Linux. Previously this was only denied from driver. How VMs should be supported is not really part of initial patch set, which makes this an obvious choice.
* Cleaned up and refined documentation to be more approachable.
v24:
* Reclaim unmeasured and TCS pages (regression in v23).
* Replace usages of GFP_HIGHUSER with GFP_KERNEL.
* Return -EIO on when EADD or EEXTEND fails in %SGX_IOC_ENCLAVE_ADD_PAGES and use the same rollback (destroy enclave). This can happen when host suspends itself unknowingly to a VM running enclaves. From -EIO the user space can deduce what happened.
* Have a separate @count in struct sgx_enclave_add_pages to output number of bytes processed instead of overwriting the input parameters for clarity and more importantly that the API provides means for partial processing (@count could be less than @length in success case).
v23:
* Replace SGX_ENCLAVE_ADD_PAGE with SGX_ENCLAVE_ADD_PAGES. Replace @mrmask with %SGX_PAGE_MEASURE flag.
* Return -EIO instead of -ECANCELED when ptrace() fails to read a TCS page.
* In the reclaimer, pin page before ENCLS[EBLOCK] because pinning can fail (because of OOM) even in legit behaviour and after EBLOCK the reclaiming flow can be only reverted by killing the whole enclave.
* Fixed SGX_ATTR_RESERVED_MASK. Bit 7 was marked as reserved while in fact it should have been bit 6 (Table 37-3 in the SDM).
* Return -EPERM from SGX_IOC_ENCLAVE_INIT when ENCLS[EINIT] returns an SGX error code.
v22:
* Refined bunch commit messages and added associated SDM references as many of them were too exhausting and some outdated.
* Alignment checks have been removed from mmap() because it does not define the ELRANGE. VMAs only act as windows to the enclave. The semantics compare somewhat how mmap() works with regular files.
* We now require user space addresses given to SGX_IOC_ENCLAVE_ADD_PAGE to be page aligned so that we can pass the page directly to EADD and do not have to do an extra copy. This was made effectively possible by removing the worker thread for adding pages.
* The selftest build files have been refined throughout of various glitches and work properly in a cross compilation environment such as BuildRoot. In addition, libcalls fail the build with an assertion in the linker script, if they end up to the enclave binary.
* CONFIG_INTEL_SGX_DRIVER has been removed because you cannot use SGX core for anything without having the driver. This could change when KVM support is added.
* We require zero permissions in SECINFO for TCS pages because the CPU overwrites SECINFO flags with zero permissions and measures the page only after that. Allowing to pass TCS with non-zero permissions would cause mismatching measurement between the one provided in SIGSTRUCT and the one computed by the CPU.
* Obviously lots of small fixes and clean ups (does make sense to document them all).
v21:
* Check on mmap() that the VMA does cover an area that does not have enclave pages. Only mapping with PROT_NONE can do that to reserve initial address space for an enclave.
* Check om mmap() and mprotect() that the VMA permissions do not surpass the enclave permissions.
* Remove two refcounts from vma_close(): mm_list and encl->refcount. Enclave refcount is only need for swapper/enclave sync and we can remove mm_list refcount by destroying mm_struct when the process is closed. By not having vm_close() the Linux MM can merge VMAs.
* Do not naturally align MAP_FIXED address.
* Numerous small fixes and clean ups.
* Use SRCU for synchronizing the list of mm_struct's.
* Move to stack based call convention in the vDSO.
v20:
* Fine-tune Kconfig messages and spacing and remove MMU_NOTIFIER dependency as MMU notifiers are no longer used in the driver.
* Use mm_users instead of mm_count as refcount for mm_struct as mm_count only protects from deleting mm_struct, not removing its contents.
* Sanitize EPC when the reclaimer thread starts by doing EREMOVE for all of them. They could be in initialized state when the kernel starts because it might be spawned by kexec().
* Documentation overhaul.
* Use a device /dev/sgx/provision for delivering the provision token instead of securityfs.
* Create a reference to the enclave when already when opening /dev/sgx/enclave. The file is then associated with this enclave only. mmap() can be done at free at any point and always get a reference to the enclave. To summarize the file now represents the enclave.
v19:
* Took 3-4 months but in some sense this was more like a rewrite of most of the corners of the source code. If I've forgotten to deal with some feedback, please don't shout me. Make a remark and I will fix it for the next version. Hopefully there won't be this big turnovers anymore.
* Validate SECS attributes properly against CPUID given attributes and against allowed attributes. SECS attributes are the ones that are enforced whereas SIGSTRUCT attributes tell what is required to run the enclave.
* Add KSS (Key Sharing Support) to the enclave attributes.
* Deny MAP_PRIVATE as an enclave is always a shared memory entity.
* Revert back to shmem backing storage so that it can be easily shared by multiple processes.
* Split the recognization of an ENCLS leaf failure by using three functions to detect it: encsl_faulted(), encls_returned_code() and sgx_failed(). encls_failed() is only caused by a spurious expections that should never happen. Thus, it is not defined as an inline function in order to easily insert a kprobe to it.
* Move low-level enclave management routines, page fault handler and page reclaiming routines from driver to the core. These cannot be separated from each other as they are heavily interdependent. The rationale is that the core does not call any code from the driver.
* Allow the driver to be compiled as a module now that it no code is using its routines and it only uses exported symbols. Now the driver is essentially just a thin ioctl layer.
* Reworked the driver to maintain a list of mm_struct's. The VMA callbacks add new entries to this list as the process is forked. Each entry has its own refcount because they have a different life-cycle as the enclave does. In effect @tgid and @mm have been removed from struct sgx_encl and we allow forking by removing VM_DONTCOPY from vm flags.
* Generate a cpu mask in the reclaimer from the cpu mask's of all mm_struct's. This will kick out the hardware threads out of the enclave from multiple processes. It is not a local variable because it would eat too much of the stack space but instead a field in struct sgx_encl.
* Allow forking i.e. remove VM_DONTCOPY. I did not change the API because the old API scaled to the workload that Andy described. The codebase is now mostly API independent i.e. changing the API is a small task. For me the proper trigger to chanage it is a as concrete as possible workload that cannot be fulfilled. I hope you understand my thinking here. I don't want to change anything w/o proper basis but I'm ready to change anything if there is a proper basis. I do not have any kind of attachment to any particular type of API.
* Add Sean's vDSO ENCLS(EENTER) patches and update selftest to use the new vDSO.
v18:
* Update the ioctl-number.txt.
* Move the driver under arch/x86.
* Add SGX features (SGX, SGX1, SGX2) to the disabled-features.h.
* Rename the selftest as test_sgx (previously sgx-selftest).
* In order to enable process accounting, swap EPC pages and PCMD's to a VMA instead of shmem.
* Allow only to initialize and run enclaves with a subset of {DEBUG, MODE64BIT} set.
* Add SGX_IOC_ENCLAVE_SET_ATTRIBUTE to allow an enclave to have privileged attributes e.g. PROVISIONKEY.
v17:
* Add a simple selftest.
* Fix a null pointer dereference to section->pages when its allocation fails.
* Add Sean's description of the exception handling to the documentation.
v16:
* Fixed SOB's in the commits that were a bit corrupted in v15.
* Implemented exceptio handling properly to detect_sgx().
* Use GENMASK() to define SGX_CPUID_SUB_LEAF_TYPE_MASK.
* Updated the documentation to use rst definition lists.
* Added the missing Documentation/x86/index.rst, which has a link to intel_sgx.rst. Now the SGX and uapi documentation is properly generated with 'make htmldocs'.
* While enumerating EPC sections, if an undefined section is found, fail the driver initialization instead of continuing the initialization.
* Issue a warning if there are more than %SGX_MAX_EPC_SECTIONS.
* Remove copyright notice from arch/x86/include/asm/sgx.h.
* Migrated from ioremap_cache() to memremap().
v15:
* Split into more digestable size patches.
* Lots of small fixes and clean ups.
* Signal a "plain" SIGSEGV on an EPCM violation.
v14:
* Change the comment about X86_FEATURE_SGX_LC from “SGX launch configuration” to “SGX launch control”.
* Move the SGX-related CPU feature flags as part of the Linux defined virtual leaf 8.
* Add SGX_ prefix to the constants defining the ENCLS leaf functions.
* Use GENMASK*() and BIT*() in sgx_arch.h instead of raw hex numbers.
* Refine the long description for CONFIG_INTEL_SGX_CORE.
* Do not use pr_*_ratelimited() in the driver. The use of the rate limited versions is legacy cruft from the prototyping phase.
* Detect sleep with SGX_INVALID_EINIT_TOKEN instead of counting power cycles.
* Manually prefix with “sgx:” in the core SGX code instead of redefining pr_fmt.
* Report if IA32_SGXLEPUBKEYHASHx MSRs are not writable in the driver instead of core because it is a driver requirement.
* Change prompt to bool in the entry for CONFIG_INTEL_SGX_CORE because the default is ‘n’.
* Rename struct sgx_epc_bank as struct sgx_epc_section in order to match the SDM.
* Allocate struct sgx_epc_page instances one at a time.
* Use “__iomem void *” pointers for the mapped EPC memory consistently.
* Retry once on SGX_INVALID_TOKEN in sgx_einit() instead of counting power cycles.
* Call enclave swapping operations directly from the driver instead of calling them .indirectly through struct sgx_epc_page_ops because indirect calls are not required yet as the patch set does not contain the KVM support.
* Added special signal SEGV_SGXERR to notify about SGX EPCM violation errors.
v13:
* Always use SGX_CPUID constant instead of a hardcoded value.
* Simplified and documented the macros and functions for ENCLS leaves.
* Enable sgx_free_page() to free active enclave pages on demand in order to allow sgx_invalidate() to delete enclave pages. It no longer performs EREMOVE if a page is in the process of being reclaimed.
* Use PM notifier per enclave so that we don't have to traverse the global list of active EPC pages to find enclaves.
* Removed unused SGX_LE_ROLLBACK constant from uapi/asm/sgx.h
* Always use ioremap() to map EPC banks as we only support 64-bit kernel.
* Invalidate IA32_SGXLEPUBKEYHASH cache used by sgx_einit() when going to sleep.
v12:
* Split to more narrow scoped commits in order to ease the review process and use co-developed-by tag for co-authors of commits instead of listing them in the source files.
* Removed cruft EXPORT_SYMBOL() declarations and converted to static variables.
* Removed in-kernel LE i.e. this version of the SGX software stack only supports unlocked IA32_SGXLEPUBKEYHASHx MSRs.
* Refined documentation on launching enclaves, swapping and enclave construction.
* Refined sgx_arch.h to include alignment information for every struct that requires it and removed structs that are not needed without an LE.
* Got rid of SGX_CPUID.
* SGX detection now prints log messages about firmware configuration issues.
v11:
* Polished ENCLS wrappers with refined exception handling.
* ksgxswapd was not stopped (regression in v5) in sgx_page_cache_teardown(), which causes a leaked kthread after driver deinitialization.
* Shutdown sgx_le_proxy when going to suspend because its EPC pages will be invalidated when resuming, which will cause it not function properly anymore.
* Set EINITTOKEN.VALID to zero for a token that is passed when SGXLEPUBKEYHASH matches MRSIGNER as alloc_page() does not give a zero page.
* Fixed the check in sgx_edbgrd() for a TCS page. Allowed to read offsets around the flags field, which causes a #GP. Only flags read is readable.
* On read access memcpy() call inside sgx_vma_access() had src and dest parameters in wrong order.
* The build issue with CONFIG_KASAN is now fixed. Added undefined symbols to LE even if “KASAN_SANITIZE := false” was set in the makefile.
* Fixed a regression in the #PF handler. If a page has SGX_ENCL_PAGE_RESERVED flag the #PF handler should unconditionally fail. It did not, which caused weird races when trying to change other parts of swapping code.
* EPC management has been refactored to a flat LRU cache and moved to arch/x86. The swapper thread reads a cluster of EPC pages and swaps all of them. It can now swap from multiple enclaves in the same round.
* For the sake of consistency with SGX_IOC_ENCLAVE_ADD_PAGE, return -EINVAL when an enclave is already initialized or dead instead of zero.
v10:
* Cleaned up anon inode based IPC between the ring-0 and ring-3 parts of the driver.
* Unset the reserved flag from an enclave page if EDBGRD/WR fails (regression in v6).
* Close the anon inode when LE is stopped (regression in v9).
* Update the documentation with a more detailed description of SGX.
v9:
* Replaced kernel-LE IPC based on pipes with an anonymous inode. The driver does not require anymore new exports.
v8:
* Check that public key MSRs match the LE public key hash in the driver initialization when the MSRs are read-only.
* Fix the race in VA slot allocation by checking the fullness immediately after succeesful allocation.
* Fix the race in hash mrsigner calculation between the launch enclave and user enclaves by having a separate lock for hash calculation.
v7:
* Fixed offset calculation in sgx_edbgr/wr(). Address was masked with PAGE_MASK when it should have been masked with ~PAGE_MASK.
* Fixed a memory leak in sgx_ioc_enclave_create().
* Simplified swapping code by using a pointer array for a cluster instead of a linked list.
* Squeezed struct sgx_encl_page to 32 bytes.
* Fixed deferencing of an RSA key on OpenSSL 1.1.0.
* Modified TC's CMAC to use kernel AES-NI. Restructured the code
a bit in order to better align with kernel conventions.
v6:
* Fixed semaphore underrun when accessing /dev/sgx from the launch enclave.
* In sgx_encl_create() s/IS_ERR(secs)/IS_ERR(encl)/.
* Removed virtualization chapter from the documentation.
* Changed the default filename for the signing key as signing_key.pem.
* Reworked EPC management in a way that instead of a linked list of struct sgx_epc_page instances there is an array of integers that encodes address and bank of an EPC page (the same data as 'pa' field earlier). The locking has been moved to the EPC bank level instead of a global lock.
* Relaxed locking requirements for EPC management. EPC pages can be released back to the EPC bank concurrently.
* Cleaned up ptrace() code.
* Refined commit messages for new architectural constants.
* Sorted includes in every source file.
* Sorted local variable declarations according to the line length in every function.
* Style fixes based on Darren's comments to sgx_le.c.
v5:
* Described IPC between the Launch Enclave and kernel in the commit messages.
* Fixed all relevant checkpatch.pl issues that I have forgot fix in earlier versions except those that exist in the imported TinyCrypt code.
* Fixed spelling mistakes in the documentation.
* Forgot to check the return value of sgx_drv_subsys_init().
* Encapsulated properly page cache init and teardown.
* Collect epc pages to a temp list in sgx_add_epc_bank
* Removed SGX_ENCLAVE_INIT_ARCH constant.
v4:
* Tied life-cycle of the sgx_le_proxy process to /dev/sgx.
* Removed __exit annotation from sgx_drv_subsys_exit().
* Fixed a leak of a backing page in sgx_process_add_page_req() in the case when vm_insert_pfn() fails.
* Removed unused symbol exports for sgx_page_cache.c.
* Updated sgx_alloc_page() to require encl parameter and documented the behavior (Sean Christopherson).
* Refactored a more lean API for sgx_encl_find() and documented the behavior.
* Moved #PF handler to sgx_fault.c.
* Replaced subsys_system_register() with plain bus_register().
* Retry EINIT 2nd time only if MSRs are not locked.
v3:
* Check that FEATURE_CONTROL_LOCKED and FEATURE_CONTROL_SGX_ENABLE are set.
* Return -ERESTARTSYS in __sgx_encl_add_page() when sgx_alloc_page() fails.
* Use unused bits in epc_page->pa to store the bank number.
* Removed #ifdef for WQ_NONREENTRANT.
* If mmu_notifier_register() fails with -EINTR, return -ERESTARTSYS.
* Added --remove-section=.got.plt to objcopy flags in order to prevent a dummy .got.plt, which will cause an inconsistent size for the LE.
* Documented sgx_encl_* functions.
* Added remark about AES implementation used inside the LE.
* Removed redundant sgx_sys_exit() from le/main.c.
* Fixed struct sgx_secinfo alignment from 128 to 64 bytes.
* Validate miscselect in sgx_encl_create().
* Fixed SSA frame size calculation to take the misc region into account.
* Implemented consistent exception handling to __encls() and __encls_ret().
* Implemented a proper device model in order to allow sysfs attributes and in-kernel API.
* Cleaned up various "find enclave" implementations to the unified sgx_encl_find().
* Validate that vm_pgoff is zero.
* Discard backing pages with shmem_truncate_range() after EADD.
* Added missing EEXTEND operations to LE signing and launch.
* Fixed SSA size for GPRS region from 168 to 184 bytes.
* Fixed the checks for TCS flags. Now DBGOPTIN is allowed.
* Check that TCS addresses are in ELRANGE and not just page aligned.
* Require kernel to be compiled with X64_64 and CPU_SUP_INTEL.
* Fixed an incorrect value for SGX_ATTR_DEBUG from 0x01 to 0x02.
v2:
* get_rand_uint32() changed the value of the pointer instead of value where it is pointing at.
* Launch enclave incorrectly used sigstruct attributes-field instead of enclave attributes-field.
* Removed unused struct sgx_add_page_req from sgx_ioctl.c
* Removed unused sgx_has_sgx2.
* Updated arch/x86/include/asm/sgx.h so that it provides stub implementations when sgx in not enabled.
* Removed cruft rdmsr-calls from sgx_set_pubkeyhash_msrs().
* return -ENOMEM in sgx_alloc_page() when VA pages consume too much space
* removed unused global sgx_nr_pids
* moved sgx_encl_release to sgx_encl.c
* return -ERESTARTSYS instead of -EINTR in sgx_encl_init()
Jarkko Sakkinen (14):
x86/sgx: Add SGX architectural data structures x86/sgx: Add wrappers for ENCLS functions x86/cpu/intel: Add nosgx kernel parameter x86/sgx: Add SGX page allocator functions x86/sgx: Add SGX misc driver interface x86/sgx: Add SGX_IOC_ENCLAVE_CREATE x86/sgx: Add SGX_IOC_ENCLAVE_ADD_PAGES x86/sgx: Add SGX_IOC_ENCLAVE_INIT x86/sgx: Add SGX_IOC_ENCLAVE_PROVISION selftests/x86: Add a selftest for SGX x86/sgx: Add a page reclaimer
x86/sgx: Add ptrace() support for the SGX driver
docs: x86/sgx: Document SGX kernel architecture x86/sgx: Update MAINTAINERS
Sean Christopherson (10):
x86/cpufeatures: x86/msr: Add Intel SGX hardware bits x86/cpufeatures: x86/msr: Add Intel SGX Launch Control hardware bits x86/sgx: Initialize metadata for Enclave Page Cache (EPC) sections x86/mm: x86/sgx: Signal SIGSEGV with PF_SGX x86/cpu/intel: Detect SGX support
mm: Add 'mprotect' hook to struct vm_operations_struct x86/vdso: Add support for exception fixup in vDSO functions x86/fault: Add helper function to sanitize error code x86/traps: Attempt to fixup exceptions in vDSO before signaling x86/vdso: Implement a vDSO for Intel SGX enclave call
.../admin-guide/kernel-parameters.txt | 2 + .../userspace-api/ioctl/ioctl-number.rst | 1 + Documentation/x86/index.rst | 1 + Documentation/x86/sgx.rst | 211 +++++ MAINTAINERS | 13 + arch/x86/Kconfig | 17 + arch/x86/entry/vdso/Makefile | 8 +- arch/x86/entry/vdso/extable.c | 46 ++ arch/x86/entry/vdso/extable.h | 28 + arch/x86/entry/vdso/vdso-layout.lds.S | 9 +- arch/x86/entry/vdso/vdso.lds.S | 1 + arch/x86/entry/vdso/vdso2c.h | 50 +- arch/x86/entry/vdso/vsgx.S | 151 ++++ arch/x86/include/asm/cpufeatures.h | 2 + arch/x86/include/asm/disabled-features.h | 8 +- arch/x86/include/asm/enclu.h | 9 + arch/x86/include/asm/msr-index.h | 8 + arch/x86/include/asm/trap_pf.h | 1 + arch/x86/include/asm/vdso.h | 5 + arch/x86/include/uapi/asm/sgx.h | 168 ++++ arch/x86/kernel/cpu/Makefile | 1 + arch/x86/kernel/cpu/feat_ctl.c | 38 +- arch/x86/kernel/cpu/sgx/Makefile | 5 + arch/x86/kernel/cpu/sgx/arch.h | 338 ++++++++ arch/x86/kernel/cpu/sgx/driver.c | 194 +++++ arch/x86/kernel/cpu/sgx/driver.h | 29 + arch/x86/kernel/cpu/sgx/encl.c | 740 ++++++++++++++++++ arch/x86/kernel/cpu/sgx/encl.h | 121 +++ arch/x86/kernel/cpu/sgx/encls.h | 231 ++++++ arch/x86/kernel/cpu/sgx/ioctl.c | 716 +++++++++++++++++ arch/x86/kernel/cpu/sgx/main.c | 731 +++++++++++++++++ arch/x86/kernel/cpu/sgx/sgx.h | 77 ++ arch/x86/kernel/traps.c | 10 + arch/x86/mm/fault.c | 45 +- include/linux/mm.h | 7 + mm/mprotect.c | 7 + tools/testing/selftests/Makefile | 1 + tools/testing/selftests/sgx/.gitignore | 2 + tools/testing/selftests/sgx/Makefile | 53 ++ tools/testing/selftests/sgx/call.S | 44 ++ tools/testing/selftests/sgx/defines.h | 21 + tools/testing/selftests/sgx/load.c | 277 +++++++ tools/testing/selftests/sgx/main.c | 246 ++++++ tools/testing/selftests/sgx/main.h | 38 + tools/testing/selftests/sgx/sigstruct.c | 391 +++++++++ tools/testing/selftests/sgx/test_encl.c | 20 + tools/testing/selftests/sgx/test_encl.lds | 40 + .../selftests/sgx/test_encl_bootstrap.S | 89 +++ 48 files changed, 5232 insertions(+), 19 deletions(-) create mode 100644 Documentation/x86/sgx.rst create mode 100644 arch/x86/entry/vdso/extable.c create mode 100644 arch/x86/entry/vdso/extable.h create mode 100644 arch/x86/entry/vdso/vsgx.S create mode 100644 arch/x86/include/asm/enclu.h create mode 100644 arch/x86/include/uapi/asm/sgx.h create mode 100644 arch/x86/kernel/cpu/sgx/Makefile create mode 100644 arch/x86/kernel/cpu/sgx/arch.h create mode 100644 arch/x86/kernel/cpu/sgx/driver.c create mode 100644 arch/x86/kernel/cpu/sgx/driver.h create mode 100644 arch/x86/kernel/cpu/sgx/encl.c create mode 100644 arch/x86/kernel/cpu/sgx/encl.h create mode 100644 arch/x86/kernel/cpu/sgx/encls.h create mode 100644 arch/x86/kernel/cpu/sgx/ioctl.c create mode 100644 arch/x86/kernel/cpu/sgx/main.c create mode 100644 arch/x86/kernel/cpu/sgx/sgx.h create mode 100644 tools/testing/selftests/sgx/.gitignore create mode 100644 tools/testing/selftests/sgx/Makefile create mode 100644 tools/testing/selftests/sgx/call.S create mode 100644 tools/testing/selftests/sgx/defines.h create mode 100644 tools/testing/selftests/sgx/load.c create mode 100644 tools/testing/selftests/sgx/main.c create mode 100644 tools/testing/selftests/sgx/main.h create mode 100644 tools/testing/selftests/sgx/sigstruct.c create mode 100644 tools/testing/selftests/sgx/test_encl.c create mode 100644 tools/testing/selftests/sgx/test_encl.lds create mode 100644 tools/testing/selftests/sgx/test_encl_bootstrap.S
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 1/24 x86/sgx: Add SGX architectural data structures
Define the SGX architectural data structures used by various SGX functions. This is not an exhaustive representation of all SGX data structures but only those needed by the kernel.
The goal is to sequester hardware structures in "sgx/arch.h" and keep them separate from kernel-internal or uapi structures.
The data structures are described in Intel SDM section 37.6.
--- arch/x86/kernel/cpu/sgx/arch.h | 338 +++++++++++++++++++++++++++++++++ 1 file changed, 338 insertions(+) create mode 100644 arch/x86/kernel/cpu/sgx/arch.h
arch/x86/kernel/cpu/sgx/arch.h new file +338 -0
@@ -0,0 +1,338 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/** +* Copyright(c) 2016-20 Intel Corporation. +* +* Contains data structures defined by the SGX architecture. Data structures +* defined by the Linux software stack should not be placed here. +*/ +#ifndef _ASM_X86_SGX_ARCH_H +#define _ASM_X86_SGX_ARCH_H + +#include <linux/bits.h> +#include <linux/types.h> + +/* The SGX specific CPUID function. */ +#define SGX_CPUID 0x12 +/* EPC enumeration. */ +#define SGX_CPUID_EPC 2 +/* An invalid EPC section, i.e. the end marker. */ +#define SGX_CPUID_EPC_INVALID 0x0 +/* A valid EPC section. */ +#define SGX_CPUID_EPC_SECTION 0x1 +/* The bitmask for the EPC section type. */ +#define SGX_CPUID_EPC_MASK GENMASK(3, 0) + +/** +* enum sgx_return_code - The return code type for ENCLS, ENCLU and ENCLV +* %SGX_NOT_TRACKED: Previous ETRACK's shootdown sequence has not +* been completed yet. +* %SGX_INVALID_EINITTOKEN: EINITTOKEN is invalid and enclave signer's +* public key does not match IA32_SGXLEPUBKEYHASH. +* %SGX_UNMASKED_EVENT: An unmasked event, e.g. INTR, was received +*/ +enum sgx_return_code { +SGX_NOT_TRACKED =11 , +SGX_INVALID_EINITTOKEN =16 , +SGX_UNMASKED_EVENT =128 , +}; + +/* The modulus size for 3072-bit RSA keys. */ +#define SGX_MODULUS_SIZE 384 + +/** +* enum sgx_miscselect - additional information to an SSA frame +* %SGX_MISC_EXINFO: Report #PF or #GP to the SSA frame. +* +* Save State Area (SSA) is a stack inside the enclave used to store processor +* state when an exception or interrupt occurs. This enum defines additional +* information stored to an SSA frame. +*/ +enum sgx_miscselect { +SGX_MISC_EXINFO =BIT (0 ), +}; + +#define SGX_MISC_RESERVED_MASK GENMASK_ULL(63, 1) + +#define SGX_SSA_GPRS_SIZE 184 +#define SGX_SSA_MISC_EXINFO_SIZE 16 + +/** +* enum sgx_attributes - the attributes field in &struct sgx_secs +* %SGX_ATTR_INIT: Enclave can be entered (is initialized). +* %SGX_ATTR_DEBUG: Allow ENCLS(EDBGRD) and ENCLS(EDBGWR). +* %SGX_ATTR_MODE64BIT: Tell that this a 64-bit enclave. +* %SGX_ATTR_PROVISIONKEY: Allow to use provisioning keys for remote +* attestation. +* %SGX_ATTR_KSS: Allow to use key separation and sharing (KSS). +* %SGX_ATTR_EINITTOKENKEY: Allow to use token signing key that is used to +* sign cryptographic tokens that can be passed to +* EINIT as an authorization to run an enclave. +*/ +enum sgx_attribute { +SGX_ATTR_INIT =BIT (0 ), +SGX_ATTR_DEBUG =BIT (1 ), +SGX_ATTR_MODE64BIT =BIT (2 ), +SGX_ATTR_PROVISIONKEY =BIT (4 ), +SGX_ATTR_EINITTOKENKEY =BIT (5 ), +SGX_ATTR_KSS =BIT (7 ), +}; + +#define SGX_ATTR_RESERVED_MASK (BIT_ULL(3) | BIT_ULL(6) | GENMASK_ULL(63, 8)) + +/** +* struct sgx_secs - SGX Enclave Control Structure (SECS) +* @size: size of the address space +* @base: base address of the address space +* @ssa_frame_size: size of an SSA frame +* @miscselect: additional information stored to an SSA frame +* @attributes: attributes for enclave +* @xfrm: XSave-Feature Request Mask (subset of XCR0) +* @mrenclave: SHA256-hash of the enclave contents +* @mrsigner: SHA256-hash of the public key used to sign the SIGSTRUCT +* @config_id: a user-defined value that is used in key derivation +* @isv_prod_id: a user-defined value that is used in key derivation +* @isv_svn: a user-defined value that is used in key derivation +* @config_svn: a user-defined value that is used in key derivation +* +* SGX Enclave Control Structure (SECS) is a special enclave page that is not +* visible in the address space. In fact, this structure defines the address +* range and other global attributes for the enclave and it is the first EPC +* page created for any enclave. It is moved from a temporary buffer to an EPC +* by the means of ENCLS[ECREATE] function. +*/ +struct sgx_secs { +u64 size; +u64 base; +u32 ssa_frame_size; +u32 miscselect; +u8 reserved1[24 ]; +u64 attributes; +u64 xfrm; +u32 mrenclave[8 ]; +u8 reserved2[32 ]; +u32 mrsigner[8 ]; +u8 reserved3[32 ]; +u32 config_id[16 ]; +u16 isv_prod_id; +u16 isv_svn; +u16 config_svn; +u8 reserved4[3834 ]; +} __packed; + +/** +* enum sgx_tcs_flags - execution flags for TCS +* %SGX_TCS_DBGOPTIN: If enabled allows single-stepping and breakpoints +* inside an enclave. It is cleared by EADD but can +* be set later with EDBGWR. +*/ +enum sgx_tcs_flags { +SGX_TCS_DBGOPTIN =0x01 , +}; + +#define SGX_TCS_RESERVED_MASK GENMASK_ULL(63, 1) +#define SGX_TCS_RESERVED_SIZE 4024 + +/** +* struct sgx_tcs - Thread Control Structure (TCS) +* @state: used to mark an entered TCS +* @flags: execution flags (cleared by EADD) +* @ssa_offset: SSA stack offset relative to the enclave base +* @ssa_index: the current SSA frame index (cleard by EADD) +* @nr_ssa_frames: the number of frame in the SSA stack +* @entry_offset: entry point offset relative to the enclave base +* @exit_addr: address outside the enclave to exit on an exception or +* interrupt +* @fs_offset: offset relative to the enclave base to become FS +* segment inside the enclave +* @gs_offset: offset relative to the enclave base to become GS +* segment inside the enclave +* @fs_limit: size to become a new FS-limit (only 32-bit enclaves) +* @gs_limit: size to become a new GS-limit (only 32-bit enclaves) +* +* Thread Control Structure (TCS) is an enclave page visible in its address +* space that defines an entry point inside the enclave. A thread enters inside +* an enclave by supplying address of TCS to ENCLU(EENTER). A TCS can be entered +* by only one thread at a time. +*/ +struct sgx_tcs { +u64 state; +u64 flags; +u64 ssa_offset; +u32 ssa_index; +u32 nr_ssa_frames; +u64 entry_offset; +u64 exit_addr; +u64 fs_offset; +u64 gs_offset; +u32 fs_limit; +u32 gs_limit; +u8 reserved[SGX_TCS_RESERVED_SIZE ]; +} __packed; + +/** +* struct sgx_pageinfo - an enclave page descriptor +* @addr: address of the enclave page +* @contents: pointer to the page contents +* @metadata: pointer either to a SECINFO or PCMD instance +* @secs: address of the SECS page +*/ +struct sgx_pageinfo { +u64 addr; +u64 contents; +u64 metadata; +u64 secs; +} __packed__aligned(32) ; + + +/** +* enum sgx_page_type - bits in the SECINFO flags defining the page type +* %SGX_PAGE_TYPE_SECS: a SECS page +* %SGX_PAGE_TYPE_TCS: a TCS page +* %SGX_PAGE_TYPE_REG: a regular page +* %SGX_PAGE_TYPE_VA: a VA page +* %SGX_PAGE_TYPE_TRIM: a page in trimmed state +*/ +enum sgx_page_type { +SGX_PAGE_TYPE_SECS , +SGX_PAGE_TYPE_TCS , +SGX_PAGE_TYPE_REG , +SGX_PAGE_TYPE_VA , +SGX_PAGE_TYPE_TRIM , +}; + +#define SGX_NR_PAGE_TYPES 5 +#define SGX_PAGE_TYPE_MASK GENMASK(7, 0) + +/** +* enum sgx_secinfo_flags - the flags field in &struct sgx_secinfo +* %SGX_SECINFO_R: allow read +* %SGX_SECINFO_W: allow write +* %SGX_SECINFO_X: allow execution +* %SGX_SECINFO_SECS: a SECS page +* %SGX_SECINFO_TCS: a TCS page +* %SGX_SECINFO_REG: a regular page +* %SGX_SECINFO_VA: a VA page +* %SGX_SECINFO_TRIM: a page in trimmed state +*/ +enum sgx_secinfo_flags { +SGX_SECINFO_R =BIT (0 ), +SGX_SECINFO_W =BIT (1 ), +SGX_SECINFO_X =BIT (2 ), +SGX_SECINFO_SECS = (SGX_PAGE_TYPE_SECS <<8 ), +SGX_SECINFO_TCS = (SGX_PAGE_TYPE_TCS <<8 ), +SGX_SECINFO_REG = (SGX_PAGE_TYPE_REG <<8 ), +SGX_SECINFO_VA = (SGX_PAGE_TYPE_VA <<8 ), +SGX_SECINFO_TRIM = (SGX_PAGE_TYPE_TRIM <<8 ), +}; + +#define SGX_SECINFO_PERMISSION_MASK GENMASK_ULL(2, 0) +#define SGX_SECINFO_PAGE_TYPE_MASK (SGX_PAGE_TYPE_MASK << 8) +#define SGX_SECINFO_RESERVED_MASK ~(SGX_SECINFO_PERMISSION_MASK | \ + SGX_SECINFO_PAGE_TYPE_MASK) + +/** +* struct sgx_secinfo - describes attributes of an EPC page +* @flags: permissions and type +* +* Used together with ENCLS leaves that add or modify an EPC page to an +* enclave to define page permissions and type. +*/ +struct sgx_secinfo { +u64 flags; +u8 reserved[56 ]; +} __packed__aligned(64) ; + +#define SGX_PCMD_RESERVED_SIZE 40 + +/** +* struct sgx_pcmd - Paging Crypto Metadata (PCMD) +* @enclave_id: enclave identifier +* @mac: MAC over PCMD, page contents and isvsvn +* +* PCMD is stored for every swapped page to the regular memory. When ELDU loads +* the page back it recalculates the MAC by using a isvsvn number stored in a +* VA page. Together these two structures bring integrity and rollback +* protection. +*/ +struct sgx_pcmd { +struct sgx_secinfo secinfo; +u64 enclave_id; +u8 reserved[SGX_PCMD_RESERVED_SIZE ]; +u8 mac[16 ]; +} __packed__aligned(128) ; + +#define SGX_SIGSTRUCT_RESERVED1_SIZE 84 +#define SGX_SIGSTRUCT_RESERVED2_SIZE 20 +#define SGX_SIGSTRUCT_RESERVED3_SIZE 32 +#define SGX_SIGSTRUCT_RESERVED4_SIZE 12 + +/** +* struct sgx_sigstruct_header - defines author of the enclave +* @header1: constant byte string +* @vendor: must be either 0x0000 or 0x8086 +* @date: YYYYMMDD in BCD +* @header2: costant byte string +* @swdefined: software defined value +*/ +struct sgx_sigstruct_header { +u64 header1[2 ]; +u32 vendor; +u32 date; +u64 header2[2 ]; +u32 swdefined; +u8 reserved1[84 ]; +} __packed; + +/** +* struct sgx_sigstruct_body - defines contents of the enclave +* @miscselect: additional information stored to an SSA frame +* @misc_mask: required miscselect in SECS +* @attributes: attributes for enclave +* @xfrm: XSave-Feature Request Mask (subset of XCR0) +* @attributes_mask: required attributes in SECS +* @xfrm_mask: required XFRM in SECS +* @mrenclave: SHA256-hash of the enclave contents +* @isvprodid: a user-defined value that is used in key derivation +* @isvsvn: a user-defined value that is used in key derivation +*/ +struct sgx_sigstruct_body { +u32 miscselect; +u32 misc_mask; +u8 reserved2[20 ]; +u64 attributes; +u64 xfrm; +u64 attributes_mask; +u64 xfrm_mask; +u8 mrenclave[32 ]; +u8 reserved3[32 ]; +u16 isvprodid; +u16 isvsvn; +} __packed; + +/** +* struct sgx_sigstruct - an enclave signature +* @header: defines author of the enclave +* @modulus: the modulus of the public key +* @exponent: the exponent of the public key +* @signature: the signature calculated over the fields except modulus, +* @body: defines contents of the enclave +* @q1: a value used in RSA signature verification +* @q2: a value used in RSA signature verification +* +* Header and body are the parts that are actual signed. The remaining fields +* define the signature of the enclave. +*/ +struct sgx_sigstruct { +struct sgx_sigstruct_header header; +u8 modulus[SGX_MODULUS_SIZE ]; +u32 exponent; +u8 signature[SGX_MODULUS_SIZE ]; +struct sgx_sigstruct_body body; +u8 reserved4[12 ]; +u8 q1[SGX_MODULUS_SIZE ]; +u8 q2[SGX_MODULUS_SIZE ]; +} __packed; + +#define SGX_LAUNCH_TOKEN_SIZE 304 + +#endif /* _ASM_X86_SGX_ARCH_H */
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 2/24 x86/sgx: Add wrappers for ENCLS functions
In reply to Jarkko SakkinenENCLS is the userspace instruction which wraps virtually all unprivileged SGX functionality for managing enclaves. It is essentially the ioctl() of instructions with each function implementing different SGX-related functionality.
Add macros to wrap the ENCLS functionality. There are two main groups, one for functions which do not return error codes and a “ret_” set for those that do.
ENCLS functions are documented in Intel SDM section 36.6.
# Co-developed-by: Sean Christopherson <[email protected]> # Signed-off-by: Sean Christopherson <[email protected]>
--- arch/x86/kernel/cpu/sgx/encls.h | 231 ++++++++++++++++++++++++++++++++ 1 file changed, 231 insertions(+) create mode 100644 arch/x86/kernel/cpu/sgx/encls.h
arch/x86/kernel/cpu/sgx/encls.h new file +231 -0
@@ -0,0 +1,231 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _X86_ENCLS_H +#define _X86_ENCLS_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 <asm/traps.h> +#include "sgx.h" + +enum sgx_encls_function { +ECREATE =0x00 , +EADD =0x01 , +EINIT =0x02 , +EREMOVE =0x03 , +EDGBRD =0x04 , +EDGBWR =0x05 , +EEXTEND =0x06 , +ELDU =0x08 , +EBLOCK =0x09 , +EPA =0x0A , +EWB =0x0B , +ETRACK =0x0C , +}; + +/** +* ENCLS_FAULT_FLAG - flag signifying an ENCLS return code is a trapnr +* +* ENCLS has its own (positive value) error codes and also generates +* ENCLS specific #GP and #PF faults. And the ENCLS values get munged +* with system error codes as everything percolates back up the stack. +* Unfortunately (for us), we need to precisely identify each unique +* error code, e.g. the action taken if EWB fails varies based on the +* type of fault and on the exact SGX error code, i.e. we can't simply +* convert all faults to -EFAULT. +* +* To make all three error types coexist, we set bit 30 to identify an +* ENCLS fault. Bit 31 (technically bits N:31) is used to differentiate +* between positive (faults and SGX error codes) and negative (system +* error codes) values. +*/ +#define ENCLS_FAULT_FLAG 0x40000000 + +/* Retrieve the encoded trapnr from the specified return code. */ +#define ENCLS_TRAPNR (r) ((r) & ~ENCLS_FAULT_FLAG) + +/* Issue a WARN() about an ENCLS function. */ +#define ENCLS_WARN (r, name) { \ + do { \ + int _r = (r); \ + WARN_ONCE(_r, "%s returned %d (0x%x)\n", (name), _r, _r); \ + } while (0); \ +} + +/** +* encls_failed() - Check if an ENCLS function failed +* @ret: the return value of an ENCLS function call +* +* Check if an ENCLS function failed. This happens when the function causes a +* fault that is not caused by an EPCM conflict or when the function returns a +* non-zero value. +*/ +static inline bool encls_failed (int ret) +{ +if (ret &ENCLS_FAULT_FLAG ) +return ENCLS_TRAPNR (ret) !=X86_TRAP_PF ; + +return !!ret; +} + +/** +* __encls_ret_N - encode an ENCLS function that returns an error code in EAX +* @rax: function number +* @inputs: asm inputs for the function +* +* Emit assembly for an ENCLS function that returns an error code, e.g. EREMOVE. +* And because SGX isn't complex enough as it is, function that return an error +* code also modify flags. +* +* Return: +* 0 on success, +* SGX error code on failure +*/ +#define __encls_ret_N(rax, inputs...) \ + ({ \ + int ret; \ + asm volatile( \ + "1: .byte 0x0f, 0x01, 0xcf;\n\t" \ + "2:\n" \ + ".section .fixup,\"ax\"\n" \ + "3: orl $"__stringify(ENCLS_FAULT_FLAG)",%%eax\n" \ + " jmp 2b\n" \ + ".previous\n" \ + _ASM_EXTABLE_FAULT(1b, 3b) \ + : "=a"(ret) \ + : "a"(rax), inputs \ + : "memory", "cc"); \ + ret; \ + }) + +#define __encls_ret_1 (rax, rcx) \ + ({ \ + __encls_ret_N(rax, "c"(rcx)); \ + }) + +#define __encls_ret_2 (rax, rbx, rcx) \ + ({ \ + __encls_ret_N(rax, "b"(rbx), "c"(rcx)); \ + }) + +#define __encls_ret_3 (rax, rbx, rcx, rdx) \ + ({ \ + __encls_ret_N(rax, "b"(rbx), "c"(rcx), "d"(rdx)); \ + }) + +/** +* __encls_N - encode an ENCLS function that doesn't return an error code +* @rax: function number +* @rbx_out: optional output variable +* @inputs: asm inputs for the function +* +* Emit assembly for an ENCLS function that does not return an error code, e.g. +* ECREATE. Leaves without error codes either succeed or fault. @rbx_out is an +* optional parameter for use by EDGBRD, which returns the requested value in +* RBX. +* +* Return: +* 0 on success, +* trapnr with ENCLS_FAULT_FLAG set on fault +*/ +#define __encls_N(rax, rbx_out, inputs...) \ + ({ \ + int ret; \ + asm volatile( \ + "1: .byte 0x0f, 0x01, 0xcf;\n\t" \ + " xor %%eax,%%eax;\n" \ + "2:\n" \ + ".section .fixup,\"ax\"\n" \ + "3: orl $"__stringify(ENCLS_FAULT_FLAG)",%%eax\n" \ + " jmp 2b\n" \ + ".previous\n" \ + _ASM_EXTABLE_FAULT(1b, 3b) \ + : "=a"(ret), "=b"(rbx_out) \ + : "a"(rax), inputs \ + : "memory"); \ + ret; \ + }) + +#define __encls_2 (rax, rbx, rcx) \ + ({ \ + unsigned long ign_rbx_out; \ + __encls_N(rax, ign_rbx_out, "b"(rbx), "c"(rcx)); \ + }) + +#define __encls_1_1 (rax, data, rcx) \ + ({ \ + unsigned long rbx_out; \ + int ret = __encls_N(rax, rbx_out, "c"(rcx)); \ + if (!ret) \ + data = rbx_out; \ + ret; \ + }) + +static inline int __ecreate (struct sgx_pageinfo *pginfo,void *secs) +{ +return __encls_2 (ECREATE , pginfo, secs); +} + +static inline int __eextend (void *secs,void *addr) +{ +return __encls_2 (EEXTEND , secs, addr); +} + +static inline int __eadd (struct sgx_pageinfo *pginfo,void *addr) +{ +return __encls_2 (EADD , pginfo, addr); +} + +static inline int __einit (void *sigstruct,void *token,void *secs) +{ +return __encls_ret_3 (EINIT , sigstruct, secs, token); +} + +static inline int __eremove (void *addr) +{ +return __encls_ret_1 (EREMOVE , addr); +} + +static inline int __edbgwr (void *addr,unsigned long *data) +{ +return __encls_2 (EDGBWR , *data, addr); +} + +static inline int __edbgrd (void *addr,unsigned long *data) +{ +return __encls_1_1 (EDGBRD , *data, addr); +} + +static inline int __etrack (void *addr) +{ +return __encls_ret_1 (ETRACK , addr); +} + +static inline int __eldu (struct sgx_pageinfo *pginfo,void *addr, +void *va) +{ +return __encls_ret_3 (ELDU , pginfo, addr, va); +} + +static inline int __eblock (void *addr) +{ +return __encls_ret_1 (EBLOCK , addr); +} + +static inline int __epa (void *addr) +{ +unsigned long rbx =SGX_PAGE_TYPE_VA ; + +return __encls_2 (EPA , rbx, addr); +} + +static inline int __ewb (struct sgx_pageinfo *pginfo,void *addr, +void *va) +{ +return __encls_ret_3 (EWB , pginfo, addr, va); +} + +#endif /* _X86_ENCLS_H */
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 3/24 x86/cpufeatures: x86/msr: Add Intel SGX hardware bits
In reply to Jarkko SakkinenFrom: Sean Christopherson <[email protected]>
Populate X86_FEATURE_SGX feature from CPUID and tie it to the Kconfig option with disabled-features.h.
IA32_FEATURE_CONTROL.SGX_ENABLE must be examined in addition to the CPUID bits to enable full SGX support. The BIOS must both set this bit and lock IA32_FEATURE_CONTROL for SGX to be supported (Intel SDM section 36.7.1). The setting or clearing of this bit has no impact on the CPUID bits above, which is why it needs to be detected separately.
# Signed-off-by: Sean Christopherson <[email protected]>
---
Changes from v39:
* Remove X86_FEATURE_SGX{1, 2}. They were only mistakenly being used for model-specific errata detection. Further, the errata does not occur on any processors that this implementation supports. Later patches ignore the errata, so remove the CPUID bits.
arch/x86/include/asm/cpufeatures.h | 1 + arch/x86/include/asm/disabled-features.h | 8 +++++++- arch/x86/include/asm/msr-index.h | 1 + 3 files changed, 9 insertions(+), 1 deletion(-)
arch/x86/include/asm/cpufeatures.h +1 -0
@@ -241,6 +241,7 @@/* Intel-defined CPU features, CPUID level 0x00000007:0 (EBX), word 9 */ #define X86_FEATURE_FSGSBASE ( 9*32+ 0)/* RDFSBASE, WRFSBASE, RDGSBASE, WRGSBASE instructions*/ #define X86_FEATURE_TSC_ADJUST ( 9*32+ 1)/* TSC adjustment MSR 0x3B */ +#define X86_FEATURE_SGX ( 9*32+ 2)/* Software Guard Extensions */ #define X86_FEATURE_BMI1 ( 9*32+ 3)/* 1st group bit manipulation extensions */ #define X86_FEATURE_HLE ( 9*32+ 4)/* Hardware Lock Elision */ #define X86_FEATURE_AVX2 ( 9*32+ 5)/* AVX2 instructions */
arch/x86/include/asm/disabled-features.h +7 -1
@@ -62,6 +62,12 @@# define DISABLE_ENQCMD (1 << (X86_FEATURE_ENQCMD & 31))#endif +#ifdef CONFIG_X86_SGX +# define DISABLE_SGX 0 +#else +# define DISABLE_SGX (1 << (X86_FEATURE_SGX & 31)) +#endif +/* * Make sure to add features to the correct mask */
@@ -74,7 +80,7 @@#define DISABLED_MASK6 0#define DISABLED_MASK7 (DISABLE_PTI)#define DISABLED_MASK8 0 -#define DISABLED_MASK9 (DISABLE_SMAP) +#define DISABLED_MASK9 (DISABLE_SMAP|DISABLE_SGX)#define DISABLED_MASK10 0#define DISABLED_MASK11 0#define DISABLED_MASK12 0
arch/x86/include/asm/msr-index.h +1 -0
@@ -610,6 +610,7 @@#define FEAT_CTL_LOCKED BIT(0)#define FEAT_CTL_VMX_ENABLED_INSIDE_SMX BIT(1)#define FEAT_CTL_VMX_ENABLED_OUTSIDE_SMX BIT(2) +#define FEAT_CTL_SGX_ENABLED BIT(18)#define FEAT_CTL_LMCE_ENABLED BIT(20)#define MSR_IA32_TSC_ADJUST 0x0000003b
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 4/24 x86/cpufeatures: x86/msr: Add Intel SGX Launch Control hardware bits
In reply to Jarkko SakkinenFrom: Sean Christopherson <[email protected]>
The SGX Launch Control hardware helps restrict which enclaves the hardware will run. Launch control is intended to restrict what software can run with enclave protections, which helps protect the overall system from bad enclaves.
For the kernel's purposes, there are effectively two modes in which the launch control hardware can operate: rigid and flexible. In its rigid mode, an entity other than the kernel has ultimate authority over which enclaves can be run (firmware, Intel, etc...). In its flexible mode, the kernel has ultimate authority over which enclaves can run.
Enable X86_FEATURE_SGX_LC to enumerate when the CPU supports SGX Launch Control in general.
Add MSR_IA32_SGXLEPUBKEYHASH{0, 1, 2, 3}, which when combined contain a SHA256 hash of a 3072-bit RSA public key. The hardware allows SGX enclaves signed with this public key to initialize and run [*]. Enclaves not signed with this key can not initialize and run.
Add FEAT_CTL_SGX_LC_ENABLED, which informs whether the SGXLEPUBKEYHASH MSRs can be written by the kernel.
If the MSRs do not exist or are read-only, the launch control hardware is operating in rigid mode. Linux does not and will not support creating enclaves when hardware is configured in rigid mode because it takes away the authority for launch decisions from the kernel. Note, this does not preclude KVM from virtualizing/exposing SGX to a KVM guest when launch control hardware is operating in rigid mode.
[*] Intel SDM: 38.1.4 Intel SGX Launch Control Configuration
# Signed-off-by: Sean Christopherson <[email protected]>
--- arch/x86/include/asm/cpufeatures.h | 1 + arch/x86/include/asm/msr-index.h | 7 +++++++ 2 files changed, 8 insertions(+)
arch/x86/include/asm/cpufeatures.h +1 -0
@@ -357,6 +357,7 @@#define X86_FEATURE_MOVDIRI (16*32+27)/* MOVDIRI instruction */ #define X86_FEATURE_MOVDIR64B (16*32+28)/* MOVDIR64B instruction */ #define X86_FEATURE_ENQCMD (16*32+29)/* ENQCMD and ENQCMDS instructions */ +#define X86_FEATURE_SGX_LC (16*32+30)/* Software Guard Extensions Launch Control */ /* AMD-defined CPU features, CPUID level 0x80000007 (EBX), word 17 */ #define X86_FEATURE_OVERFLOW_RECOV (17*32+ 0)/* MCA overflow recovery support */
arch/x86/include/asm/msr-index.h +7 -0
@@ -610,6 +610,7 @@#define FEAT_CTL_LOCKED BIT(0)#define FEAT_CTL_VMX_ENABLED_INSIDE_SMX BIT(1)#define FEAT_CTL_VMX_ENABLED_OUTSIDE_SMX BIT(2) +#define FEAT_CTL_SGX_LC_ENABLED BIT(17)#define FEAT_CTL_SGX_ENABLED BIT(18)#define FEAT_CTL_LMCE_ENABLED BIT(20)
@@ -630,6 +631,12 @@#define MSR_IA32_UCODE_WRITE 0x00000079#define MSR_IA32_UCODE_REV 0x0000008b +/* Intel SGX Launch Enclave Public Key Hash MSRs */ +#define MSR_IA32_SGXLEPUBKEYHASH0 0x0000008C +#define MSR_IA32_SGXLEPUBKEYHASH1 0x0000008D +#define MSR_IA32_SGXLEPUBKEYHASH2 0x0000008E +#define MSR_IA32_SGXLEPUBKEYHASH3 0x0000008F +#define MSR_IA32_SMM_MONITOR_CTL 0x0000009b#define MSR_IA32_SMBASE 0x0000009e
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 5/24 x86/sgx: Initialize metadata for Enclave Page Cache (EPC) sections
In reply to Jarkko SakkinenFrom: Sean Christopherson <[email protected]>
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 <[email protected]>
---
Changes from v39:
* Replace CONFIG_INTEL_SGX with CONFIG_X86_SGX.
Changes from v40:
* Renamed 'ksgxswapd' as 'ksgxd'.
arch/x86/Kconfig | 17 +++ arch/x86/kernel/cpu/Makefile | 1 + arch/x86/kernel/cpu/sgx/Makefile | 2 + arch/x86/kernel/cpu/sgx/main.c | 190 +++++++++++++++++++++++++++++++ arch/x86/kernel/cpu/sgx/sgx.h | 60 ++++++++++ 5 files changed, 270 insertions(+) create mode 100644 arch/x86/kernel/cpu/sgx/Makefile create mode 100644 arch/x86/kernel/cpu/sgx/main.c create mode 100644 arch/x86/kernel/cpu/sgx/sgx.h
arch/x86/Kconfig +17 -0
@@ -1931,6 +1931,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
arch/x86/kernel/cpu/Makefile +1 -0
@@ -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
arch/x86/kernel/cpu/sgx/Makefile new file +2 -0
@@ -0,0 +1,2 @@ +obj-y += \ + main.o
arch/x86/kernel/cpu/sgx/main.c new file +190 -0
190 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/sgx.h new file +60 -0
60 lines not on this page · raw message
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 6/24 x86/mm: x86/sgx: Signal SIGSEGV with PF_SGX
In reply to Jarkko SakkinenFrom: Sean Christopherson <[email protected]>
The x86 architecture has a set of page fault error codes. These indicate things like whether the fault occurred from a write, or whether it originated in userspace.
The SGX hardware architecture has its own per-page memory management metadata (EPCM) [*] and hardware which is separate from the normal x86 MMU. The architecture has a new page fault error code: PF_SGX. This new error code bit is set whenever a page fault occurs as the result of the SGX MMU.
These faults occur for a variety of reasons. For instance, an access attempt to enclave memory from outside the enclave causes a PF_SGX fault. PF_SGX would also be set for permission conflicts, such as if a write to an enclave page occurs and the page is marked read-write in the x86 page tables but is read-only in the EPCM.
These faults do not always indicate errors, though. SGX pages are encrypted with a key that is destroyed at hardware reset, including suspend. Throwing a SIGSEGV allows user space software to react and recover when these events occur.
Include PF_SGX in the PF error codes list and throw SIGSEGV when it is encountered.
[*] Intel SDM: 36.5.1 Enclave Page Cache Map (EPCM)
# Signed-off-by: Sean Christopherson <[email protected]>
--- arch/x86/include/asm/trap_pf.h | 1 + arch/x86/mm/fault.c | 12 ++++++++++++ 2 files changed, 13 insertions(+)
arch/x86/include/asm/trap_pf.h +1 -0
@@ -19,6 +19,7 @@ enum x86_pf_error_code {X86_PF_RSVD =1 <<3 ,X86_PF_INSTR =1 <<4 ,X86_PF_PK =1 <<5 , + X86_PF_SGX = 1 << 15, };#endif /* _ASM_X86_TRAP_PF_H */
arch/x86/mm/fault.c +12 -0
@@ -1101,6 +1101,18 @@ access_error(unsigned long error_code, struct vm_area_struct *vma)if (error_code &X86_PF_PK )return 1 ; +/* +* SGX hardware blocked the access. This usually happens +* when the enclave memory contents have been destroyed, like +* after a suspend/resume cycle. In any case, the kernel can't +* fix the cause of the fault. Handle the fault as an access +* error even in cases where no actual access violation +* occurred. This allows userspace to rebuild the enclave in +* response to the signal. +*/ +if (unlikely (error_code &X86_PF_SGX )) +return 1 ; +/* * Make sure to check the VMA so that we do not perform * faults just to hit a X86_PF_PK as soon as we fill in a
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 7/24 x86/cpu/intel: Detect SGX support
In reply to Jarkko SakkinenFrom: Sean Christopherson <[email protected]>
Kernel support for SGX is ultimately decided by the state of the launch control bits in the feature control MSR (MSR_IA32_FEAT_CTL). If the hardware supports SGX, but neglects to support flexible launch control, the kernel will not enable SGX.
Enable SGX at feature control MSR initialization and update the associated X86_FEATURE flags accordingly. Disable X86_FEATURE_SGX (and all derivatives) if the kernel is not able to establish itself as the authority over SGX Launch Control.
All checks are performed for each logical CPU (not just boot CPU) in order to verify that MSR_IA32_FEATURE_CONTROL is correctly configured on all CPUs. All SGX code in this series expects the same configuration from all CPUs.
This differs from VMX where X86_FEATURE_VMX is intentionally cleared only for the current CPU so that KVM can provide additional information if KVM fails to load like which CPU doesn't support VMX. There’s not much the kernel or an administrator can do to fix the situation, so SGX neglects to convey additional details about these kinds of failures if they occur.
# Signed-off-by: Sean Christopherson <[email protected]>
--- arch/x86/kernel/cpu/feat_ctl.c | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-)
arch/x86/kernel/cpu/feat_ctl.c +28 -1
@@ -93,16 +93,32 @@ static void init_vmx_capabilities(struct cpuinfo_x86 *c) }#endif /* CONFIG_X86_VMX_FEATURE_NAMES */ +static void clear_sgx_caps (void ) +{ +setup_clear_cpu_cap (X86_FEATURE_SGX ); +setup_clear_cpu_cap (X86_FEATURE_SGX_LC ); +} +void init_ia32_feat_ctl (struct cpuinfo_x86 *c) {bool tboot =tboot_enabled (); +bool enable_sgx;u64 msr;if (rdmsrl_safe (MSR_IA32_FEAT_CTL , &msr)) {clear_cpu_cap (c,X86_FEATURE_VMX ); +clear_sgx_caps ();return ; } +/* +* Enable SGX if and only if the kernel supports SGX and Launch Control +* is supported, i.e. disable SGX if the LE hash MSRs can't be written. +*/ + enable_sgx =cpu_has (c,X86_FEATURE_SGX ) && +cpu_has (c,X86_FEATURE_SGX_LC ) && +IS_ENABLED (CONFIG_X86_SGX ); +if (msr &FEAT_CTL_LOCKED ) goto update_caps;
@@ -124,13 +140,16 @@ void init_ia32_feat_ctl(struct cpuinfo_x86 *c) msr |=FEAT_CTL_VMX_ENABLED_INSIDE_SMX ; } +if (enable_sgx) + msr |=FEAT_CTL_SGX_ENABLED |FEAT_CTL_SGX_LC_ENABLED ; +wrmsrl (MSR_IA32_FEAT_CTL , msr); update_caps:set_cpu_cap (c,X86_FEATURE_MSR_IA32_FEAT_CTL );if (!cpu_has (c,X86_FEATURE_VMX )) -return ; + goto update_sgx;if ( (tboot && !(msr &FEAT_CTL_VMX_ENABLED_INSIDE_SMX )) || (!tboot && !(msr &FEAT_CTL_VMX_ENABLED_OUTSIDE_SMX ))) {
@@ -143,4 +162,12 @@ void init_ia32_feat_ctl(struct cpuinfo_x86 *c)init_vmx_capabilities (c);#endif } + +update_sgx: +if (!(msr &FEAT_CTL_SGX_ENABLED ) || + !(msr &FEAT_CTL_SGX_LC_ENABLED ) || !enable_sgx) { +if (enable_sgx) +pr_err_once ("SGX disabled by BIOS\n" ); +clear_sgx_caps (); + } }
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 8/24 x86/cpu/intel: Add nosgx kernel parameter
In reply to Jarkko SakkinenAdd kernel parameter to disable Intel SGX kernel support, along with supporting Documentation.
# Tested-by: Sean Christopherson <[email protected]> # Reviewed-by: Sean Christopherson <[email protected]>
--- Documentation/admin-guide/kernel-parameters.txt | 2 ++ arch/x86/kernel/cpu/feat_ctl.c | 9 +++++++++ 2 files changed, 11 insertions(+)
Documentation/admin-guide/kernel-parameters.txt +2 -0
@@ -3385,6 +3385,8 @@ nosep [BUGS=X86-32] Disables x86 SYSENTER/SYSEXIT support. + nosgx [X86-64,SGX] Disables Intel SGX kernel support. + nosmp [SMP] Tells an SMP kernel to act as a UP kernel, and disable the IO APIC. legacy for "maxcpus=0".
arch/x86/kernel/cpu/feat_ctl.c +9 -0
@@ -99,6 +99,15 @@ static void clear_sgx_caps(void)setup_clear_cpu_cap (X86_FEATURE_SGX_LC ); } +static int __init nosgx (char *str) +{ +clear_sgx_caps (); + +return 0 ; +} + +early_param ("nosgx" , nosgx); +void init_ia32_feat_ctl (struct cpuinfo_x86 *c) {bool tboot =tboot_enabled ();
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 9/24 x86/sgx: Add SGX page allocator functions
In reply to Jarkko SakkinenThe previous patch initialized a simple SGX page allocator. Add functions for runtime allocation and free.
This allocator and its algorithms are as simple as it gets. They do a linear search across all EPC sections and find the first free page. They are not NUMA aware and only hand out individual pages. The SGX hardware does not support large pages, so something more complicated like a buddy allocator is unwarranted.
The free function (sgx_free_epc_page()) implicitly calls ENCLS[EREMOVE], which returns the page to the uninitialized state. This ensures that the page is ready for use at the next allocation.
# Co-developed-by: Sean Christopherson <[email protected]> # Signed-off-by: Sean Christopherson <[email protected]>
--- arch/x86/kernel/cpu/sgx/main.c | 65 ++++++++++++++++++++++++++++++++++ arch/x86/kernel/cpu/sgx/sgx.h | 3 ++ 2 files changed, 68 insertions(+)
arch/x86/kernel/cpu/sgx/main.c +65 -0
@@ -85,6 +85,71 @@ static bool __init sgx_page_reclaimer_init(void)return true; } +static struct sgx_epc_page *__sgx_alloc_epc_page_from_section (struct sgx_epc_section *section) +{ +struct sgx_epc_page *page; + +spin_lock (§ion->lock); + +if (list_empty (§ion->page_list)) { +spin_unlock (§ion->lock); +return NULL ; + } + + page = list_first_entry(§ion->page_list, struct sgx_epc_page, list); +list_del_init (&page->list); + +spin_unlock (§ion->lock); +return page; +} + +/** +* __sgx_alloc_epc_page() - Allocate an EPC page +* +* Iterate through EPC sections and borrow a free EPC page to the caller. When a +* page is no longer needed it must be released with sgx_free_epc_page(). +* +* Return: +* an EPC page, +* -errno on error +*/ +struct sgx_epc_page *__sgx_alloc_epc_page (void ) +{ +struct sgx_epc_section *section; +struct sgx_epc_page *page; +int i; + +for (i =0 ; i < sgx_nr_epc_sections; i++) { + section = &sgx_epc_sections[i]; + + page =__sgx_alloc_epc_page_from_section (section); +if (page) +return page; + } + +return ERR_PTR (-ENOMEM ); +} + +/** +* sgx_free_epc_page() - Free an EPC page +* @page: an EPC page +* +* Call EREMOVE for an EPC page and insert it back to the list of free pages. +*/ +void sgx_free_epc_page (struct sgx_epc_page *page) +{ +struct sgx_epc_section *section = &sgx_epc_sections[page->section]; +int ret; + + ret =__eremove (sgx_get_epc_virt_addr (page)); +if (WARN_ONCE (ret,"EREMOVE returned %d (0x%x)" , ret, ret)) +return ; + +spin_lock (§ion->lock); +list_add_tail (&page->list, §ion->page_list); +spin_unlock (§ion->lock); +} +static bool __init sgx_setup_epc_section (u64 phys_addr,u64 size,unsigned long index,struct sgx_epc_section *section)
arch/x86/kernel/cpu/sgx/sgx.h +3 -0
@@ -57,4 +57,7 @@ static inline void *sgx_get_epc_virt_addr(struct sgx_epc_page *page) return section->virt_addr + index * PAGE_SIZE; } +struct sgx_epc_page *__sgx_alloc_epc_page (void ); +void sgx_free_epc_page (struct sgx_epc_page *page); +#endif /* _X86_SGX_H */
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 10/24 mm: Add 'mprotect' hook to struct vm_operations_struct
In reply to Jarkko SakkinenFrom: Sean Christopherson <[email protected]>
Background
==========
1. SGX enclave pages are populated with data by copying from normal memory via ioctl() (SGX_IOC_ENCLAVE_ADD_PAGES), which will be added later in this series.
2. It is desirable to be able to restrict those normal memory data sources. For instance, to ensure that the source data is executable before copying data to an executable enclave page.
3. Enclave page permissions are dynamic (just like normal permissions) and can be adjusted at runtime with mprotect().
This creates a problem because the original data source may have long since vanished at the time when enclave page permissions are established (mmap() or mprotect()).
The solution (elsewhere in this series) is to force enclaves creators to declare their paging permission *intent* up front to the ioctl(). This intent can be immediately compared to the source data’s mapping and rejected if necessary.
The “intent” is also stashed off for later comparison with enclave PTEs. This ensures that any future mmap()/mprotect() operations performed by the enclave creator or done on behalf of the enclave can be compared with the earlier declared permissions.
Problem
=======
There is an existing mmap() hook which allows SGX to perform this permission comparison at mmap() time. However, there is no corresponding ->mprotect() hook.
Solution
========
Add a vm_ops->mprotect() hook so that mprotect() operations which are inconsistent with any page's stashed intent can be rejected by the driver.
# Signed-off-by: Sean Christopherson <[email protected]>
---
Changes from v40:
* Move mprotect_fixup() outside of the callback. This keeps mm internals outside of the callback.
include/linux/mm.h | 7 +++++++ mm/mprotect.c | 7 +++++++ 2 files changed, 14 insertions(+)
include/linux/mm.h +7 -0
@@ -559,6 +559,13 @@ struct vm_operations_struct {void (*close)(struct vm_area_struct * area);int (*split)(struct vm_area_struct * area,unsigned long addr);int (*mremap)(struct vm_area_struct * area); +/* +* Called by mprotect() to make driver-specific permission +* checks before mprotect() is finalised. The VMA must not +* be modified. Returns 0 if eprotect() can proceed. +*/ +int (*mprotect)(struct vm_area_struct *vma,unsigned long start, +unsigned long end,unsigned long newflags);vm_fault_t (*fault)(struct vm_fault *vmf);vm_fault_t (*huge_fault)(struct vm_fault *vmf,enum page_entry_size pe_size);
mm/mprotect.c +7 -0
@@ -616,9 +616,16 @@ static int do_mprotect_pkey(unsigned long start, size_t len, tmp = vma->vm_end;if (tmp > end) tmp = end; + +if (vma->vm_ops && vma->vm_ops->mprotect) + error = vma->vm_ops->mprotect (vma, nstart, tmp, newflags); +if (error) + goto out; + error =mprotect_fixup (vma, &prev, nstart, tmp, newflags);if (error) goto out; + nstart = tmp;if (nstart < prev->vm_end)
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 11/24 x86/sgx: Add SGX misc driver interface
In reply to Jarkko SakkinenIntel(R) SGX is new hardware functionality that can be used by applications to set aside private regions of code and data called enclaves. New hardware protects enclave code and data from outside access and modification.
Add a driver that presents a device file and ioctl API to build and manage enclaves. Subsequent patches will expend the ioctl()’s functionality.
# Co-developed-by: Sean Christopherson <[email protected]> # Signed-off-by: Sean Christopherson <[email protected]>
---
Changes from v40:
* Do not check !page in sgx_encl_may_map() while iterating.
* Do not check !vm_private_data in sgx_encl_find(), as the enclave is created at VFS open.
Changes from v39:
* Rename /dev/sgx/enclave as /dev/sgx_enclave.
* In the page fault handler, do not check for SGX_ENCL_DEAD. This allows to do forensics to the memory of debug enclaves.
arch/x86/kernel/cpu/sgx/Makefile | 2 + arch/x86/kernel/cpu/sgx/driver.c | 112 ++++++++++++++++++++++++ arch/x86/kernel/cpu/sgx/driver.h | 16 ++++ arch/x86/kernel/cpu/sgx/encl.c | 146 +++++++++++++++++++++++++++++++ arch/x86/kernel/cpu/sgx/encl.h | 60 +++++++++++++ arch/x86/kernel/cpu/sgx/main.c | 12 ++- 6 files changed, 347 insertions(+), 1 deletion(-) create mode 100644 arch/x86/kernel/cpu/sgx/driver.c create mode 100644 arch/x86/kernel/cpu/sgx/driver.h create mode 100644 arch/x86/kernel/cpu/sgx/encl.c create mode 100644 arch/x86/kernel/cpu/sgx/encl.h
arch/x86/kernel/cpu/sgx/Makefile +2 -0
@@ -1,2 +1,4 @@ obj-y += \ + driver.o \ + encl.o \ main.o
arch/x86/kernel/cpu/sgx/driver.c new file +112 -0
112 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/driver.h new file +16 -0
@@ -0,0 +1,16 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __ARCH_SGX_DRIVER_H__ +#define __ARCH_SGX_DRIVER_H__ + +#include <crypto/hash.h> +#include <linux/kref.h> +#include <linux/mmu_notifier.h> +#include <linux/radix-tree.h> +#include <linux/rwsem.h> +#include <linux/sched.h> +#include <linux/workqueue.h> +#include "sgx.h" + +int sgx_drv_init (void ); + +#endif /* __ARCH_X86_SGX_DRIVER_H__ */
arch/x86/kernel/cpu/sgx/encl.c new file +146 -0
146 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/encl.h new file +60 -0
60 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/main.c +11 -1
@@ -9,6 +9,8 @@#include <linux/sched/mm.h> #include <linux/sched/signal.h> #include <linux/slab.h> +#include "driver.h" +#include "encl.h" #include "encls.h" struct sgx_epc_section sgx_epc_sections[SGX_MAX_EPC_SECTIONS ];
@@ -232,9 +234,10 @@ static bool __init sgx_page_cache_init(void)static void __init sgx_init (void ) { +int ret;int i; -if (!boot_cpu_has (X86_FEATURE_SGX )) +if (!cpu_feature_enabled (X86_FEATURE_SGX ))return ;if (!sgx_page_cache_init ())
@@ -243,8 +246,15 @@ static void __init sgx_init(void)if (!sgx_page_reclaimer_init ()) goto err_page_cache; + ret =sgx_drv_init (); +if (ret) + goto err_kthread; +return ; +err_kthread: +kthread_stop (ksgxd_tsk); + err_page_cache:for (i =0 ; i < sgx_nr_epc_sections; i++) {vfree (sgx_epc_sections[i].pages);
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 12/24 x86/sgx: Add SGX_IOC_ENCLAVE_CREATE
In reply to Jarkko SakkinenAdd an ioctl() that performs ECREATE function of ENCLS instruction, which creates SGX Enclave Control Structure (SECS).
Although the SECS is an in-memory data structure, it is present in enclave memory and is not directly accessible by software.
# Co-developed-by: Sean Christopherson <[email protected]> # Signed-off-by: Sean Christopherson <[email protected]>
---
Changes from v39:
* Remove sgx_validate_secs() and ECREATE do the validation. If it fails, return -EIO.
.../userspace-api/ioctl/ioctl-number.rst | 1 + arch/x86/include/uapi/asm/sgx.h | 25 ++++ arch/x86/kernel/cpu/sgx/Makefile | 1 + arch/x86/kernel/cpu/sgx/driver.c | 12 ++ arch/x86/kernel/cpu/sgx/driver.h | 3 + arch/x86/kernel/cpu/sgx/encl.c | 8 ++ arch/x86/kernel/cpu/sgx/encl.h | 7 + arch/x86/kernel/cpu/sgx/ioctl.c | 123 ++++++++++++++++++ 8 files changed, 180 insertions(+) create mode 100644 arch/x86/include/uapi/asm/sgx.h create mode 100644 arch/x86/kernel/cpu/sgx/ioctl.c
Documentation/userspace-api/ioctl/ioctl-number.rst +1 -0
@@ -323,6 +323,7 @@ Code Seq# Include File Comments <mailto:[email protected]> 0xA3 90-9F linux/dtlk.h 0xA4 00-1F uapi/linux/tee.h Generic TEE subsystem +0xA4 00-1F uapi/asm/sgx.h <mailto:[email protected]> 0xAA 00-3F linux/uapi/linux/userfaultfd.h 0xAB 00-1F linux/nbd.h 0xAC 00-1F linux/raw.h
arch/x86/include/uapi/asm/sgx.h new file +25 -0
@@ -0,0 +1,25 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +/* +* Copyright(c) 2016-20 Intel Corporation. +*/ +#ifndef _UAPI_ASM_X86_SGX_H +#define _UAPI_ASM_X86_SGX_H + +#include <linux/types.h> +#include <linux/ioctl.h> + +#define SGX_MAGIC 0xA4 + +#define SGX_IOC_ENCLAVE_CREATE \ + _IOW(SGX_MAGIC, 0x00, struct sgx_enclave_create) + +/** +* struct sgx_enclave_create - parameter structure for the +* %SGX_IOC_ENCLAVE_CREATE ioctl +* @src: address for the SECS page data +*/ +struct sgx_enclave_create { +__u64 src; +}; + +#endif /* _UAPI_ASM_X86_SGX_H */
arch/x86/kernel/cpu/sgx/Makefile +1 -0
@@ -1,4 +1,5 @@ obj-y += \ driver.o \ encl.o \ + ioctl.o \ main.o
arch/x86/kernel/cpu/sgx/driver.c +12 -0
@@ -88,10 +88,22 @@ static unsigned long sgx_get_unmapped_area(struct file *file,return current->mm->get_unmapped_area (file, addr, len, pgoff, flags); } +#ifdef CONFIG_COMPAT +static long sgx_compat_ioctl (struct file *filep,unsigned int cmd, +unsigned long arg) +{ +return sgx_ioctl (filep, cmd, arg); +} +#endif +static const struct file_operations sgx_encl_fops = { .owner =THIS_MODULE , .open = sgx_open, .release = sgx_release, + .unlocked_ioctl = sgx_ioctl, +#ifdef CONFIG_COMPAT + .compat_ioctl = sgx_compat_ioctl, +#endif .mmap = sgx_mmap, .get_unmapped_area = sgx_get_unmapped_area, };
arch/x86/kernel/cpu/sgx/driver.h +3 -0
@@ -9,8 +9,11 @@#include <linux/rwsem.h> #include <linux/sched.h> #include <linux/workqueue.h> +#include <uapi/asm/sgx.h> #include "sgx.h" +long sgx_ioctl (struct file *filep,unsigned int cmd,unsigned long arg); +int sgx_drv_init (void );#endif /* __ARCH_X86_SGX_DRIVER_H__ */
arch/x86/kernel/cpu/sgx/encl.c +8 -0
@@ -46,6 +46,7 @@ static vm_fault_t sgx_vma_fault(struct vm_fault *vmf)struct sgx_encl_page *entry;unsigned long phys_addr;struct sgx_encl *encl; +unsigned long pfn;vm_fault_t ret; encl = vma->vm_private_data;
@@ -61,6 +62,13 @@ static vm_fault_t sgx_vma_fault(struct vm_fault *vmf) phys_addr =sgx_get_epc_phys_addr (entry->epc_page); +/* Check if another thread got here first to insert the PTE. */ +if (!follow_pfn (vma, addr, &pfn)) { +mutex_unlock (&encl->lock); + +return VM_FAULT_NOPAGE ; + } + ret =vmf_insert_pfn (vma, addr,PFN_DOWN (phys_addr));if (ret !=VM_FAULT_NOPAGE ) {mutex_unlock (&encl->lock);
arch/x86/kernel/cpu/sgx/encl.h +7 -0
@@ -26,9 +26,16 @@ struct sgx_encl_page {struct sgx_encl *encl; }; +enum sgx_encl_flags { +SGX_ENCL_IOCTL =BIT (0 ), +SGX_ENCL_DEBUG =BIT (1 ), +SGX_ENCL_CREATED =BIT (2 ), +}; +struct sgx_encl {unsigned long base;unsigned long size; +unsigned long flags;unsigned int page_cnt;unsigned int secs_child_cnt;struct mutex lock;
arch/x86/kernel/cpu/sgx/ioctl.c new file +123 -0
123 lines not on this page · raw message
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 13/24 x86/sgx: Add SGX_IOC_ENCLAVE_ADD_PAGES
In reply to Jarkko SakkinenSGX enclave pages are inaccessible to normal software. They must be populated with data by copying from normal memory with the help of the EADD and EEXTEND functions of the ENCLS instruction.
Add an ioctl() which performs EADD that adds new data to an enclave, and optionally EEXTEND functions that hash the page contents and use the hash as part of enclave “measurement” to ensure enclave integrity.
The enclave author gets to decide which pages will be included in the enclave measurement with EEXTEND. Measurement is very slow and has sometimes has very little value. For instance, an enclave _could_ measure every page of data and code, but would be slow to initialize. Or, it might just measure its code and then trust that code to initialize the bulk of its data after it starts running.
# Co-developed-by: Sean Christopherson <[email protected]> # Signed-off-by: Sean Christopherson <[email protected]>
---
Changes from v39:
* Remove unneeded access_ok(). It is taken care of by get_user_pages().
* Define SGX_EEXTEND_BLOCK_SIZE to capture the block size used with EEXTEND.
* When EADD or EEXTEND fail, just return -EIO. Leave the enclave cleanup as the duty of VFS and the page reclaimer.
* Remove SGX_MAX_ADD_PAGES_LENGTH, as the ioctl can be interrupted anyway.
arch/x86/include/uapi/asm/sgx.h | 30 ++++ arch/x86/kernel/cpu/sgx/ioctl.c | 284 ++++++++++++++++++++++++++++++++ arch/x86/kernel/cpu/sgx/sgx.h | 1 + 3 files changed, 315 insertions(+)
arch/x86/include/uapi/asm/sgx.h +30 -0
@@ -8,10 +8,21 @@#include <linux/types.h> #include <linux/ioctl.h> +/** +* enum sgx_epage_flags - page control flags +* %SGX_PAGE_MEASURE: Measure the page contents with a sequence of +* ENCLS[EEXTEND] operations. +*/ +enum sgx_page_flags { +SGX_PAGE_MEASURE =0x01 , +}; +#define SGX_MAGIC 0xA4#define SGX_IOC_ENCLAVE_CREATE \ _IOW(SGX_MAGIC, 0x00, struct sgx_enclave_create) +#define SGX_IOC_ENCLAVE_ADD_PAGES \ + _IOWR(SGX_MAGIC, 0x01, struct sgx_enclave_add_pages)/** * struct sgx_enclave_create - parameter structure for the
@@ -22,4 +33,23 @@ struct sgx_enclave_create { __u64 src; }; +/** +* struct sgx_enclave_add_pages - parameter structure for the +* %SGX_IOC_ENCLAVE_ADD_PAGE ioctl +* @src: start address for the page data +* @offset: starting page offset +* @length: length of the data (multiple of the page size) +* @secinfo: address for the SECINFO data +* @flags: page control flags +* @count: number of bytes added (multiple of the page size) +*/ +struct sgx_enclave_add_pages { +__u64 src; +__u64 offset; +__u64 length; +__u64 secinfo; +__u64 flags; +__u64 count; +}; +#endif /* _UAPI_ASM_X86_SGX_H */
arch/x86/kernel/cpu/sgx/ioctl.c +284 -0
296 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/sgx.h +1 -0
@@ -14,6 +14,7 @@#define pr_fmt (fmt) "sgx: " fmt#define SGX_MAX_EPC_SECTIONS 8 +#define SGX_EEXTEND_BLOCK_SIZE 256struct sgx_epc_page {unsigned int section;
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 14/24 x86/sgx: Add SGX_IOC_ENCLAVE_INIT
In reply to Jarkko SakkinenEnclaves have two basic states. They are either being built and are malleable and can be modified by doing things like adding pages. Or, they are locked down and not accepting changes. They can only be run after they have been locked down. The ENCLS[EINIT] function induces the transition from being malleable to locked-down.
Add an ioctl() that performs ENCLS[EINIT]. After this, new pages can no longer be added with ENCLS[EADD]. This is also the time where the enclave can be measured to verify its integrity.
# Co-developed-by: Sean Christopherson <[email protected]> # Signed-off-by: Sean Christopherson <[email protected]>
---
Changes from v39:
* Declare 'k' for the MSR updating loop. It was incorrectly using 'i'.
* Return -EIO instead of -EFAULT on EINIT failure, just like happens when EADD or EEXTEND fails.
* When EINIT fails, just return -EIO. Leave the enclave cleanup as the duty of VFS and the page reclaimer.
arch/x86/include/uapi/asm/sgx.h | 11 ++ arch/x86/kernel/cpu/sgx/driver.c | 27 +++++ arch/x86/kernel/cpu/sgx/driver.h | 8 ++ arch/x86/kernel/cpu/sgx/encl.h | 3 + arch/x86/kernel/cpu/sgx/ioctl.c | 193 ++++++++++++++++++++++++++++++- 5 files changed, 241 insertions(+), 1 deletion(-)
arch/x86/include/uapi/asm/sgx.h +11 -0
@@ -23,6 +23,8 @@ enum sgx_page_flags { _IOW(SGX_MAGIC, 0x00, struct sgx_enclave_create)#define SGX_IOC_ENCLAVE_ADD_PAGES \ _IOWR(SGX_MAGIC, 0x01, struct sgx_enclave_add_pages) +#define SGX_IOC_ENCLAVE_INIT \ + _IOW(SGX_MAGIC, 0x02, struct sgx_enclave_init)/** * struct sgx_enclave_create - parameter structure for the
@@ -52,4 +54,13 @@ struct sgx_enclave_add_pages { __u64 count; }; +/** +* struct sgx_enclave_init - parameter structure for the +* %SGX_IOC_ENCLAVE_INIT ioctl +* @sigstruct: address for the SIGSTRUCT data +*/ +struct sgx_enclave_init { +__u64 sigstruct; +}; +#endif /* _UAPI_ASM_X86_SGX_H */
arch/x86/kernel/cpu/sgx/driver.c +27 -0
@@ -10,6 +10,10 @@#include "driver.h" #include "encl.h" +u64 sgx_attributes_reserved_mask; +u64 sgx_xfrm_reserved_mask = ~0x3 ; +u32 sgx_misc_reserved_mask; +static int sgx_open (struct inode *inode,struct file *file) {struct sgx_encl *encl;
@@ -117,8 +121,31 @@ static struct miscdevice sgx_dev_enclave = {int __init sgx_drv_init (void ) { +unsigned int eax, ebx, ecx, edx; +u64 attr_mask; +u64 xfrm_mask; +if (!cpu_feature_enabled (X86_FEATURE_SGX_LC ))return -ENODEV ; +cpuid_count (SGX_CPUID ,0 , &eax, &ebx, &ecx, &edx); + +if (!(eax &1 )) { +pr_err ("SGX disabled: SGX1 instruction support not available.\n" ); +return -ENODEV ; + } + + sgx_misc_reserved_mask = ~ebx |SGX_MISC_RESERVED_MASK ; + +cpuid_count (SGX_CPUID ,1 , &eax, &ebx, &ecx, &edx); + + attr_mask = (((u64 )ebx) <<32 ) + (u64 )eax; + sgx_attributes_reserved_mask = ~attr_mask |SGX_ATTR_RESERVED_MASK ; + +if (cpu_feature_enabled (X86_FEATURE_OSXSAVE )) { + xfrm_mask = (((u64 )edx) <<32 ) + (u64 )ecx; + sgx_xfrm_reserved_mask = ~xfrm_mask; + } +return misc_register (&sgx_dev_enclave); }
arch/x86/kernel/cpu/sgx/driver.h +8 -0
@@ -12,6 +12,14 @@#include <uapi/asm/sgx.h> #include "sgx.h" +#define SGX_EINIT_SPIN_COUNT 20 +#define SGX_EINIT_SLEEP_COUNT 50 +#define SGX_EINIT_SLEEP_TIME 20 + +extern u64 sgx_attributes_reserved_mask; +extern u64 sgx_xfrm_reserved_mask; +extern u32 sgx_misc_reserved_mask; +long sgx_ioctl (struct file *filep,unsigned int cmd,unsigned long arg);int sgx_drv_init (void );
arch/x86/kernel/cpu/sgx/encl.h +3 -0
@@ -30,6 +30,7 @@ enum sgx_encl_flags {SGX_ENCL_IOCTL =BIT (0 ),SGX_ENCL_DEBUG =BIT (1 ),SGX_ENCL_CREATED =BIT (2 ), + SGX_ENCL_INITIALIZED = BIT(3), }; struct sgx_encl {
@@ -41,6 +42,8 @@ struct sgx_encl {struct mutex lock;struct xarray page_array;struct sgx_encl_page secs; +unsigned long attributes; +unsigned long attributes_mask; };extern const struct vm_operations_struct sgx_vm_ops;
arch/x86/kernel/cpu/sgx/ioctl.c +192 -1
217 lines not on this page · raw message
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 15/24 x86/sgx: Add SGX_IOC_ENCLAVE_PROVISION
In reply to Jarkko SakkinenThe whole point of SGX is to create a hardware protected place to do “stuff”. But, before someone is willing to hand the keys to the castle over, an enclave must often prove that it is running on an SGX-protected processor. Provisioning enclaves play a key role in providing proof.
There are actually three different enclaves in play in order to make this happen:
1. The application enclave. The familiar one we know and love that runs the actual code that’s doing real work. There can be many of these on a single system, or even in a single application.
2. The quoting enclave (QE). The QE is mentioned in lots of silly whitepapers, but, for the purposes of kernel enabling, just pretend they do not exist.
3. The provisioning enclave. There is typically only one of these enclaves per system. Provisioning enclaves have access to a special hardware key.
They can use this key to help to generate certificates which serve as proof that enclaves are running on trusted SGX hardware. These certificates can be passed around without revealing the special key.
Any user which can create a provisioning enclave can access the processor-unique Provisioning Certificate Key which has privacy and fingerprinting implications. Even if a user is permitted to create normal application enclaves (via /dev/sgx_enclave), they should not be able to create provisioning enclaves. That means a separate permissions scheme is needed to control provisioning enclave privileges.
Implement a separate device file (/dev/sgx_provision) which permits creating provisioning enclaves. This device will typically have more strict permissions than the plain enclave device.
The actual device “driver” is an empty stub. Open file descriptors for this device will represent a token which allows provisioning enclave duty. This file descriptor can be passed around and ultimately given as an argument to the /dev/sgx_enclave driver ioctl().
---
Changes from v39:
* Rename /dev/sgx/provision as /dev/sgx_provision.
arch/x86/include/uapi/asm/sgx.h | 11 ++++++++++ arch/x86/kernel/cpu/sgx/driver.c | 24 ++++++++++++++++++++- arch/x86/kernel/cpu/sgx/driver.h | 2 ++ arch/x86/kernel/cpu/sgx/ioctl.c | 37 ++++++++++++++++++++++++++++++++ 4 files changed, 73 insertions(+), 1 deletion(-)
arch/x86/include/uapi/asm/sgx.h +11 -0
@@ -25,6 +25,8 @@ enum sgx_page_flags { _IOWR(SGX_MAGIC, 0x01, struct sgx_enclave_add_pages)#define SGX_IOC_ENCLAVE_INIT \ _IOW(SGX_MAGIC, 0x02, struct sgx_enclave_init) +#define SGX_IOC_ENCLAVE_PROVISION \ + _IOW(SGX_MAGIC, 0x03, struct sgx_enclave_provision)/** * struct sgx_enclave_create - parameter structure for the
@@ -63,4 +65,13 @@ struct sgx_enclave_init { __u64 sigstruct; }; +/** +* struct sgx_enclave_provision - parameter structure for the +* %SGX_IOC_ENCLAVE_PROVISION ioctl +* @fd: file handle of /dev/sgx_provision +*/ +struct sgx_enclave_provision { +__u64 fd; +}; +#endif /* _UAPI_ASM_X86_SGX_H */
arch/x86/kernel/cpu/sgx/driver.c +23 -1
@@ -112,6 +112,10 @@ static const struct file_operations sgx_encl_fops = { .get_unmapped_area = sgx_get_unmapped_area, }; +const struct file_operations sgx_provision_fops = { + .owner =THIS_MODULE , +}; +static struct miscdevice sgx_dev_enclave = { .minor =MISC_DYNAMIC_MINOR , .name ="sgx_enclave" ,
@@ -119,11 +123,19 @@ static struct miscdevice sgx_dev_enclave = { .fops = &sgx_encl_fops, }; +static struct miscdevice sgx_dev_provision = { + .minor =MISC_DYNAMIC_MINOR , + .name ="sgx_provision" , + .nodename ="sgx_provision" , + .fops = &sgx_provision_fops, +}; +int __init sgx_drv_init (void ) {unsigned int eax, ebx, ecx, edx;u64 attr_mask;u64 xfrm_mask; +int ret;if (!cpu_feature_enabled (X86_FEATURE_SGX_LC ))return -ENODEV ;
@@ -147,5 +159,15 @@ int __init sgx_drv_init(void) sgx_xfrm_reserved_mask = ~xfrm_mask; } -return misc_register (&sgx_dev_enclave); + ret =misc_register (&sgx_dev_enclave); +if (ret) +return ret; + + ret =misc_register (&sgx_dev_provision); +if (ret) { +misc_deregister (&sgx_dev_enclave); +return ret; + } + +return 0 ; }
arch/x86/kernel/cpu/sgx/driver.h +2 -0
@@ -20,6 +20,8 @@ extern u64 sgx_attributes_reserved_mask;extern u64 sgx_xfrm_reserved_mask;extern u32 sgx_misc_reserved_mask; +extern const struct file_operations sgx_provision_fops; +long sgx_ioctl (struct file *filep,unsigned int cmd,unsigned long arg);int sgx_drv_init (void );
arch/x86/kernel/cpu/sgx/ioctl.c +37 -0
@@ -569,6 +569,40 @@ static long sgx_ioc_enclave_init(struct sgx_encl *encl, void __user *arg)return ret; } +/** +* sgx_ioc_enclave_provision() - handler for %SGX_IOC_ENCLAVE_PROVISION +* @enclave: an enclave pointer +* @arg: userspace pointer to a struct sgx_enclave_provision instance +* +* Allow ATTRIBUTE.PROVISION_KEY for an enclave by providing a file handle to +* /dev/sgx_provision. +* +* Return: +* - 0: Success. +* - -errno: Otherwise. +*/ +static long sgx_ioc_enclave_provision (struct sgx_encl *encl,void __user *arg) +{ +struct sgx_enclave_provision params; +struct file *file; + +if (copy_from_user (¶ms, arg,sizeof (params))) +return -EFAULT ; + + file =fget (params.fd); +if (!file) +return -EINVAL ; + +if (file->f_op != &sgx_provision_fops) { +fput (file); +return -EINVAL ; + } + + encl->attributes_mask |=SGX_ATTR_PROVISIONKEY ; + +fput (file); +return 0 ; +}long sgx_ioctl (struct file *filep,unsigned int cmd,unsigned long arg) {
@@ -588,6 +622,9 @@ long sgx_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)case SGX_IOC_ENCLAVE_INIT : ret =sgx_ioc_enclave_init (encl, (void __user *)arg);break ; +case SGX_IOC_ENCLAVE_PROVISION : + ret =sgx_ioc_enclave_provision (encl, (void __user *)arg); +break ;default : ret = -ENOIOCTLCMD ;break ;
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 16/24 x86/vdso: Add support for exception fixup in vDSO functions
In reply to Jarkko SakkinenFrom: Sean Christopherson <[email protected]>
Signals are a horrid little mechanism. They are especially nasty in multi-threaded environments because signal state like handlers is global across the entire process. But, signals are basically the only way that userspace can “gracefully” handle and recover from exceptions.
The kernel generally does not like exceptions to occur during execution. But, exceptions are a fact of life and must be handled in some circumstances. The kernel handles them by keeping a list of individual instructions which may cause exceptions. Instead of truly handling the exception and returning to the instruction that caused it, the kernel instead restarts execution at a *different* instruction. This makes it obvious to that thread of execution that the exception occurred and lets *that* code handle the exception instead of the handler.
This is not dissimilar to the try/catch exceptions mechanisms that some programming languages have, but applied *very* surgically to single instructions. It effectively changes the visible architecture of the instruction.
Problem
=======
SGX generates a lot of signals, and the code to enter and exit enclaves and muck with signal handling is truly horrid. At the same time, an approach like kernel exception fixup can not be easily applied to userspace instructions because it changes the visible instruction architecture.
Solution
========
The vDSO is a special page of kernel-provided instructions that run in userspace. Any userspace calling into the vDSO knows that it is special. This allows the kernel a place to legitimately rewrite the user/kernel contract and change instruction behavior.
Add support for fixing up exceptions that occur while executing in the vDSO. This replaces what could traditionally only be done with signal handling.
This new mechanism will be used to replace previously direct use of SGX instructions by userspace.
Just introduce the vDSO infrastructure. Later patches will actually replace signal generation with vDSO exception fixup.
# Signed-off-by: Sean Christopherson <[email protected]>
--- arch/x86/entry/vdso/Makefile | 6 ++-- arch/x86/entry/vdso/extable.c | 46 ++++++++++++++++++++++++ arch/x86/entry/vdso/extable.h | 28 +++++++++++++++ arch/x86/entry/vdso/vdso-layout.lds.S | 9 ++++- arch/x86/entry/vdso/vdso2c.h | 50 ++++++++++++++++++++++++++- arch/x86/include/asm/vdso.h | 5 +++ 6 files changed, 139 insertions(+), 5 deletions(-) create mode 100644 arch/x86/entry/vdso/extable.c create mode 100644 arch/x86/entry/vdso/extable.h
arch/x86/entry/vdso/Makefile +3 -3
@@ -29,7 +29,7 @@ vobjs32-y := vdso32/note.o vdso32/system_call.o vdso32/sigreturn.o vobjs32-y += vdso32/vclock_gettime.o # files to link into kernel -obj-y += vma.o +obj-y += vma.o extable.o KASAN_SANITIZE_vma.o := y UBSAN_SANITIZE_vma.o := y KCSAN_SANITIZE_vma.o := y
@@ -128,8 +128,8 @@ $(obj)/%-x32.o: $(obj)/%.o FORCE targets += vdsox32.lds $(vobjx32s-y) -$(obj)/%.so: OBJCOPYFLAGS := -S -$(obj)/%.so: $(obj)/%.so.dbg FORCE +$(obj)/%.so: OBJCOPYFLAGS := -S --remove-section __ex_table +$(obj)/%.so: $(obj)/%.so.dbg $(call if_changed,objcopy) $(obj)/vdsox32.so.dbg: $(obj)/vdsox32.lds $(vobjx32s) FORCE
arch/x86/entry/vdso/extable.c new file +46 -0
46 lines not on this page · raw message
arch/x86/entry/vdso/extable.h new file +28 -0
@@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __VDSO_EXTABLE_H +#define __VDSO_EXTABLE_H + +/* +* Inject exception fixup for vDSO code. Unlike normal exception fixup, +* vDSO uses a dedicated handler the addresses are relative to the overall +* exception table, not each individual entry. +*/ +#ifdef __ASSEMBLY__ +#define _ASM_VDSO_EXTABLE_HANDLE (from, to) \ + ASM_VDSO_EXTABLE_HANDLE from to + +.macro ASM_VDSO_EXTABLE_HANDLE from:req to:req + .pushsection __ex_table, "a" + .long (\from) - __ex_table + .long (\to) - __ex_table + .popsection +.endm +#else +#define _ASM_VDSO_EXTABLE_HANDLE (from, to) \ + ".pushsection __ex_table, \"a\"\n" \ + ".long (" #from ") - __ex_table\n" \ + ".long (" #to ") - __ex_table\n" \ + ".popsection\n" +#endif + +#endif /* __VDSO_EXTABLE_H */
arch/x86/entry/vdso/vdso-layout.lds.S +8 -1
@@ -75,11 +75,18 @@ SECTIONS * stuff that isn't used at runtime in between. */ - .text : { *(.text*) } :text =0x90909090, + .text : { + *(.text*) + *(.fixup) + } :text =0x90909090, + + .altinstructions : { *(.altinstructions) } :text .altinstr_replacement : { *(.altinstr_replacement) } :text + __ex_table : { *(__ex_table) } :text + /DISCARD/ : { *(.discard) *(.discard.*)
arch/x86/entry/vdso/vdso2c.h +49 -1
80 lines not on this page · raw message
arch/x86/include/asm/vdso.h +5 -0
@@ -15,6 +15,8 @@ struct vdso_image {unsigned long size;/* Always a multiple of PAGE_SIZE */ unsigned long alt, alt_len; +unsigned long extable_base, extable_len; +const void *extable;long sym_vvar_start;/* Negative offset to the vvar area */
@@ -45,6 +47,9 @@ extern void __init init_vdso_image(const struct vdso_image *image);extern int map_vdso_once (const struct vdso_image *image,unsigned long addr); +extern bool fixup_vdso_exception (struct pt_regs *regs,int trapnr, +unsigned long error_code, +unsigned long fault_addr);#endif /* __ASSEMBLER__ */ #endif /* _ASM_X86_VDSO_H */
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 17/24 x86/fault: Add helper function to sanitize error code
In reply to Jarkko SakkinenFrom: Sean Christopherson <[email protected]>
vDSO exception fixup is a replacement for signals in limited situations. Signals and vDSO exception fixup need to provide similar information to userspace, including the hardware error code.
That hardware error code needs to be sanitized. For instance, if userspace accesses a kernel address, the error code could indicate to userspace whether the address had a Present=1 PTE. That can leak information about the kernel layout to userspace, which is bad.
The existing signal code does this sanitization, but fairly late in the signal process. The vDSO exception code runs before the sanitization happens.
Move error code sanitization out of the signal code and into a helper. Call the helper in the signal code.
# Signed-off-by: Sean Christopherson <[email protected]>
---
Changes from v39:
* Add the missing change to the set_signal_archinfo() that removes the snippet contained in sanitize_error_code().
arch/x86/mm/fault.c | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-)
arch/x86/mm/fault.c +14 -12
@@ -602,11 +602,9 @@ pgtable_bad(struct pt_regs *regs, unsigned long error_code,oops_end (flags, regs, sig); } -static void set_signal_archinfo (unsigned long address, -unsigned long error_code) +static void sanitize_error_code (unsigned long address, +unsigned long *error_code) { -struct task_struct *tsk = current; -/* * To avoid leaking information about the kernel page * table layout, pretend that user-mode accesses to
@@ -617,7 +615,13 @@ static void set_signal_archinfo(unsigned long address,* information and does not appear to cause any problems. */ if (address >=TASK_SIZE_MAX ) - error_code |=X86_PF_PROT ; + *error_code |=X86_PF_PROT ; +} + +static void set_signal_archinfo (unsigned long address, +unsigned long error_code) +{ +struct task_struct *tsk = current; tsk->thread.trap_nr =X86_TRAP_PF ; tsk->thread.error_code = error_code |X86_PF_USER ;
@@ -658,6 +662,8 @@ no_context(struct pt_regs *regs, unsigned long error_code,* faulting through the emulate_vsyscall() logic. */ if (current->thread.sig_on_uaccess_err && signal) { +sanitize_error_code (address, &error_code); +set_signal_archinfo (address, error_code);/* XXX: hwpoison faults will set the wrong code. */
@@ -806,13 +812,7 @@ __bad_area_nosemaphore(struct pt_regs *regs, unsigned long error_code,if (is_errata100 (regs, address))return ; -/* -* To avoid leaking information about the kernel page table -* layout, pretend that user-mode accesses to kernel addresses -* are always protection faults. -*/ -if (address >=TASK_SIZE_MAX ) - error_code |=X86_PF_PROT ; +sanitize_error_code (address, &error_code);if (likely (show_unhandled_signals))show_signal_msg (regs, error_code, address, tsk);
@@ -931,6 +931,8 @@ do_sigbus(struct pt_regs *regs, unsigned long error_code, unsigned long address,if (is_prefetch (regs, error_code, address))return ; +sanitize_error_code (address, &error_code); +set_signal_archinfo (address, error_code);#ifdef CONFIG_MEMORY_FAILURE
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 18/24 x86/traps: Attempt to fixup exceptions in vDSO before signaling
In reply to Jarkko SakkinenFrom: Sean Christopherson <[email protected]>
vDSO functions can now leverage an exception fixup mechanism similar to kernel exception fixup. For vDSO exception fixup, the initial user is Intel's Software Guard Extensions (SGX), which will wrap the low-level transitions to/from the enclave, i.e. EENTER and ERESUME instructions, in a vDSO function and leverage fixup to intercept exceptions that would otherwise generate a signal. This allows the vDSO wrapper to return the fault information directly to its caller, obviating the need for SGX applications and libraries to juggle signal handlers.
Attempt to fixup vDSO exceptions immediately prior to populating and sending signal information. Except for the delivery mechanism, an exception in a vDSO function should be treated like any other exception in userspace, e.g. any fault that is successfully handled by the kernel should not be directly visible to userspace.
Although it's debatable whether or not all exceptions are of interest to enclaves, defer to the vDSO fixup to decide whether to do fixup or generate a signal. Future users of vDSO fixup, if there ever are any, will undoubtedly have different requirements than SGX enclaves, e.g. the fixup vs. signal logic can be made function specific if/when necessary.
# Signed-off-by: Sean Christopherson <[email protected]>
--- arch/x86/kernel/traps.c | 10 ++++++++++ arch/x86/mm/fault.c | 7 +++++++ 2 files changed, 17 insertions(+)
arch/x86/kernel/traps.c +10 -0
@@ -60,6 +60,7 @@#include <asm/umip.h> #include <asm/insn.h> #include <asm/insn-eval.h> +#include <asm/vdso.h> #ifdef CONFIG_X86_64 #include <asm/x86_init.h>
@@ -117,6 +118,9 @@ do_trap_no_signal(struct task_struct *tsk, int trapnr, const char *str, tsk->thread.error_code = error_code; tsk->thread.trap_nr = trapnr;die (str, regs, error_code); + }else { +if (fixup_vdso_exception (regs, trapnr, error_code,0 )) +return 0 ; }/*
@@ -550,6 +554,9 @@ DEFINE_IDTENTRY_ERRORCODE(exc_general_protection) tsk->thread.error_code = error_code; tsk->thread.trap_nr =X86_TRAP_GP ; +if (fixup_vdso_exception (regs,X86_TRAP_GP , error_code,0 )) +return ; +show_signal (tsk,SIGSEGV ,"" , desc, regs, error_code);force_sig (SIGSEGV ); goto exit;
@@ -1049,6 +1056,9 @@ static void math_error(struct pt_regs *regs, int trapnr)if (!si_code) goto exit; +if (fixup_vdso_exception (regs, trapnr,0 ,0 )) +return ; +force_sig_fault (SIGFPE , si_code, (void __user *)uprobe_get_trap_addr (regs)); exit:
arch/x86/mm/fault.c +7 -0
@@ -30,6 +30,7 @@#include <asm/cpu_entry_area.h> /* exception stack */ #include <asm/pgtable_areas.h> /* VMALLOC_START, ... */ #include <asm/kvm_para.h> /* kvm_handle_async_pf */ +#include <asm/vdso.h> /* fixup_vdso_exception() */ #define CREATE_TRACE_POINTS #include <asm/trace/exceptions.h>
@@ -814,6 +815,9 @@ __bad_area_nosemaphore(struct pt_regs *regs, unsigned long error_code,sanitize_error_code (address, &error_code); +if (fixup_vdso_exception (regs,X86_TRAP_PF , error_code, address)) +return ; +if (likely (show_unhandled_signals))show_signal_msg (regs, error_code, address, tsk);
@@ -933,6 +937,9 @@ do_sigbus(struct pt_regs *regs, unsigned long error_code, unsigned long address,sanitize_error_code (address, &error_code); +if (fixup_vdso_exception (regs,X86_TRAP_PF , error_code, address)) +return ; +set_signal_archinfo (address, error_code);#ifdef CONFIG_MEMORY_FAILURE
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 19/24 x86/vdso: Implement a vDSO for Intel SGX enclave call
In reply to Jarkko SakkinenFrom: Sean Christopherson <[email protected]>
Enclaves encounter exceptions for lots of reasons: everything from enclave page faults to NULL pointer dereferences, to system calls that must be “proxied” to the kernel from outside the enclave.
In addition to the code contained inside an enclave, there is also supporting code outside the enclave called an “SGX runtime”, which is virtually always implemented inside a shared library. The runtime helps build the enclave and handles things like *re*building the enclave if it got destroyed by something like a suspend/resume cycle.
The rebuilding has traditionally been handled in SIGSEGV handlers, registered by the library. But, being process-wide, shared state, signal handling and shared libraries do not mix well.
Introduce a vDSO function call that wraps the enclave entry functions (EENTER/ERESUME functions of the ENCLU instruciton) and returns information about any exceptions to the caller in the SGX runtime.
Instead of generating a signal, the kernel places exception information in RDI, RSI and RDX. The kernel-provided userspace portion of the vDSO handler will place this information in a user-provided buffer or trigger a user-provided callback at the time of the exception.
The vDSO function calling convention uses the standard RDI RSI, RDX, RCX, R8 and R9 registers. This makes it possible to declare the vDSO as a C prototype, but other than that there is no specific support for SystemV ABI. Things like storing XSAVE are the responsibility of the enclave and the runtime.
# Signed-off-by: Sean Christopherson <[email protected]>
---
Changes from v39:
* Relaid out the user handler documentation: return values are described in sgx_enclave_user_handler_t keneldoc and broad description is given in struct sgx_enclave_run kerneldoc.
* Renamed @leaf as @function, given that we want to speak consistently about ENCLS and ENCLU functions.
* Reorder user_handler and user_data as the last fields in sgx_enclave_run, as they are an extension to the basic functionality.
arch/x86/entry/vdso/Makefile | 2 + arch/x86/entry/vdso/vdso.lds.S | 1 + arch/x86/entry/vdso/vsgx.S | 151 ++++++++++++++++++++++++++++++++ arch/x86/include/asm/enclu.h | 9 ++ arch/x86/include/uapi/asm/sgx.h | 91 +++++++++++++++++++ 5 files changed, 254 insertions(+) create mode 100644 arch/x86/entry/vdso/vsgx.S create mode 100644 arch/x86/include/asm/enclu.h
arch/x86/entry/vdso/Makefile +2 -0
@@ -27,6 +27,7 @@ VDSO32-$(CONFIG_IA32_EMULATION) := y vobjs-y := vdso-note.o vclock_gettime.o vgetcpu.o vobjs32-y := vdso32/note.o vdso32/system_call.o vdso32/sigreturn.o vobjs32-y += vdso32/vclock_gettime.o +vobjs-$(VDSO64-y) += vsgx.o # files to link into kernel obj-y += vma.o extable.o
@@ -98,6 +99,7 @@ $(vobjs): KBUILD_CFLAGS := $(filter-out $(GCC_PLUGINS_CFLAGS) $(RETPOLINE_CFLAGS CFLAGS_REMOVE_vclock_gettime.o = -pg CFLAGS_REMOVE_vdso32/vclock_gettime.o = -pg CFLAGS_REMOVE_vgetcpu.o = -pg +CFLAGS_REMOVE_vsgx.o = -pg # # X32 processes use x32 vDSO to access 64bit kernel data.
arch/x86/entry/vdso/vdso.lds.S +1 -0
@@ -27,6 +27,7 @@ VERSION { __vdso_time; clock_getres; __vdso_clock_getres; + __vdso_sgx_enter_enclave; local: *; }; }
arch/x86/entry/vdso/vsgx.S new file +151 -0
151 lines not on this page · raw message
arch/x86/include/asm/enclu.h new file +9 -0
@@ -0,0 +1,9 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_X86_ENCLU_H +#define _ASM_X86_ENCLU_H + +#define EENTER 0x02 +#define ERESUME 0x03 +#define EEXIT 0x04 + +#endif /* _ASM_X86_ENCLU_H */
arch/x86/include/uapi/asm/sgx.h +91 -0
95 lines not on this page · raw message
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 20/24 selftests/x86: Add a selftest for SGX
In reply to Jarkko SakkinenAdd a selftest for SGX. It is a trivial test where a simple enclave copies one 64-bit word of memory between two memory locations, but ensures that all SGX hardware and software infrastructure is functioning.
---
Changes from v40:
* Remove $(OUTPUT)/test_encl.elf from TEST_CUSTOM_PROGS, as otherwise run_tests tries to execute it. Add it as a build dependency.
* Use the correct device path, /dev/sgx_enclave, instead of /dev/sgx/enclave.
* Return kselftest framework expected return codes.
tools/testing/selftests/Makefile | 1 + tools/testing/selftests/sgx/.gitignore | 2 + tools/testing/selftests/sgx/Makefile | 53 +++ tools/testing/selftests/sgx/call.S | 44 ++ tools/testing/selftests/sgx/defines.h | 21 + tools/testing/selftests/sgx/load.c | 277 +++++++++++++ tools/testing/selftests/sgx/main.c | 246 +++++++++++ tools/testing/selftests/sgx/main.h | 38 ++ tools/testing/selftests/sgx/sigstruct.c | 391 ++++++++++++++++++ tools/testing/selftests/sgx/test_encl.c | 20 + tools/testing/selftests/sgx/test_encl.lds | 40 ++ .../selftests/sgx/test_encl_bootstrap.S | 89 ++++ 12 files changed, 1222 insertions(+) create mode 100644 tools/testing/selftests/sgx/.gitignore create mode 100644 tools/testing/selftests/sgx/Makefile create mode 100644 tools/testing/selftests/sgx/call.S create mode 100644 tools/testing/selftests/sgx/defines.h create mode 100644 tools/testing/selftests/sgx/load.c create mode 100644 tools/testing/selftests/sgx/main.c create mode 100644 tools/testing/selftests/sgx/main.h create mode 100644 tools/testing/selftests/sgx/sigstruct.c create mode 100644 tools/testing/selftests/sgx/test_encl.c create mode 100644 tools/testing/selftests/sgx/test_encl.lds create mode 100644 tools/testing/selftests/sgx/test_encl_bootstrap.S
tools/testing/selftests/Makefile +1 -0
@@ -68,6 +68,7 @@ TARGETS += user TARGETS += vm TARGETS += x86 TARGETS += zram +TARGETS += sgx #Please keep the TARGETS list alphabetically sorted # Run "make quicktest=1 run_tests" or # "make quicktest=1 kselftest" from top level Makefile
tools/testing/selftests/sgx/.gitignore new file +2 -0
@@ -0,0 +1,2 @@ +test_sgx +test_encl.elf
tools/testing/selftests/sgx/Makefile new file +53 -0
53 lines not on this page · raw message
tools/testing/selftests/sgx/call.S new file +44 -0
44 lines not on this page · raw message
tools/testing/selftests/sgx/defines.h new file +21 -0
@@ -0,0 +1,21 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright(c) 2016-20 Intel Corporation. +*/ + +#ifndef DEFINES_H +#define DEFINES_H + +#include <stdint.h> + +#define PAGE_SIZE 4096 +#define PAGE_MASK (~(PAGE_SIZE - 1)) + +#define __aligned (x) __attribute__((__aligned__(x))) +#define __packed __attribute__((packed)) + +#include "../../../../arch/x86/kernel/cpu/sgx/arch.h" +#include "../../../../arch/x86/include/asm/enclu.h" +#include "../../../../arch/x86/include/uapi/asm/sgx.h" + +#endif /* DEFINES_H */
tools/testing/selftests/sgx/load.c new file +277 -0
277 lines not on this page · raw message
tools/testing/selftests/sgx/main.c new file +246 -0
246 lines not on this page · raw message
tools/testing/selftests/sgx/main.h new file +38 -0
@@ -0,0 +1,38 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright(c) 2016-20 Intel Corporation. +*/ + +#ifndef MAIN_H +#define MAIN_H + +struct encl_segment { +off_t offset; +size_t size; +unsigned int prot; +unsigned int flags; +}; + +struct encl { +int fd; +void *bin; +off_t bin_size; +void *src; +size_t src_size; +size_t encl_size; +off_t encl_base; +unsigned int nr_segments; +struct encl_segment *segment_tbl; +struct sgx_secs secs; +struct sgx_sigstruct sigstruct; +}; + +void encl_delete (struct encl *ctx); +bool encl_load (const char *path,struct encl *encl); +bool encl_measure (struct encl *encl); +bool encl_build (struct encl *encl); + +int sgx_call_vdso (void *rdi,void *rsi,long rdx,u32 function,void *r8,void *r9, +struct sgx_enclave_run *run); + +#endif /* MAIN_H */
tools/testing/selftests/sgx/sigstruct.c new file +391 -0
391 lines not on this page · raw message
tools/testing/selftests/sgx/test_encl.c new file +20 -0
@@ -0,0 +1,20 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright(c) 2016-20 Intel Corporation. */ + +#include <stddef.h> +#include "defines.h" + +static void *memcpy (void *dest,const void *src,size_t n) +{ +size_t i; + +for (i =0 ; i < n; i++) + ((char *)dest)[i] = ((char *)src)[i]; + +return dest; +} + +void encl_body (void *rdi,void *rsi) +{ +memcpy (rsi, rdi,8 ); +}
tools/testing/selftests/sgx/test_encl.lds new file +40 -0
@@ -0,0 +1,40 @@ +OUTPUT_FORMAT(elf64-x86-64) + +PHDRS +{ + tcs PT_LOAD; + text PT_LOAD; + data PT_LOAD; +} + +SECTIONS +{ + . = 0; + .tcs : { + *(.tcs*) + } : tcs + + . = ALIGN(4096); + .text : { + *(.text*) + *(.rodata*) + } : text + + . = ALIGN(4096); + .data : { + *(.data*) + } : data + + /DISCARD/ : { + *(.comment*) + *(.note*) + *(.debug*) + *(.eh_frame*) + } +} + +ASSERT(!DEFINED(.altinstructions), "ALTERNATIVES are not supported in enclaves") +ASSERT(!DEFINED(.altinstr_replacement), "ALTERNATIVES are not supported in enclaves") +ASSERT(!DEFINED(.discard.retpoline_safe), "RETPOLINE ALTERNATIVES are not supported in enclaves") +ASSERT(!DEFINED(.discard.nospec), "RETPOLINE ALTERNATIVES are not supported in enclaves") +ASSERT(!DEFINED(.got.plt), "Libcalls are not supported in enclaves")
tools/testing/selftests/sgx/test_encl_bootstrap.S new file +89 -0
89 lines not on this page · raw message
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 21/24 x86/sgx: Add a page reclaimer
In reply to Jarkko SakkinenJust like normal RAM, there is a limited amount of enclave memory available and overcommitting it is a very valuable tool to reduce resource use. Introduce a simple reclaim mechanism for enclave pages.
In contrast to normal page reclaim, the kernel cannot directly access enclave memory. To get around this, the SGX architecture provides a set of functions to help. Among other things, these functions copy enclave memory to and from normal memory, encrypting it and protecting its integrity in the process.
Implement a page reclaimer by using these functions. Picks victim pages in LRU fashion from all the enclaves running in the system. A new kernel thread (ksgxswapd) reclaims pages in the background based on watermarks, similar to normal kswapd.
All enclave pages can be reclaimed, architecturally. But, there are some limits on this, such as the special SECS metadata page which must be reclaimed last. The page version array (used to mitigate replaying old reclaimed pages) is also architecturally reclaimable, but not yet implemented. The end result is that the vast majority of enclave pages are currently reclaimable.
# Co-developed-by: Sean Christopherson <[email protected]> # Signed-off-by: Sean Christopherson <[email protected]>
---
Changes from v39:
* Remove SGX_ENCL_DEAD checks from the page reclaimer. They are no longer needed as enclave contents are deleted only when it is released.
arch/x86/kernel/cpu/sgx/driver.c | 59 ++-- arch/x86/kernel/cpu/sgx/encl.c | 483 ++++++++++++++++++++++++++++++- arch/x86/kernel/cpu/sgx/encl.h | 51 ++++ arch/x86/kernel/cpu/sgx/ioctl.c | 89 +++++- arch/x86/kernel/cpu/sgx/main.c | 466 +++++++++++++++++++++++++++++ arch/x86/kernel/cpu/sgx/sgx.h | 13 + 6 files changed, 1134 insertions(+), 27 deletions(-)
arch/x86/kernel/cpu/sgx/driver.c +40 -19
@@ -17,13 +17,24 @@ u32 sgx_misc_reserved_mask;static int sgx_open (struct inode *inode,struct file *file) {struct sgx_encl *encl; +int ret; encl =kzalloc (sizeof (*encl),GFP_KERNEL );if (!encl)return -ENOMEM ; +kref_init (&encl->refcount);xa_init (&encl->page_array);mutex_init (&encl->lock); +INIT_LIST_HEAD (&encl->va_pages); +INIT_LIST_HEAD (&encl->mm_list); +spin_lock_init (&encl->mm_lock); + + ret =init_srcu_struct (&encl->srcu); +if (ret) { +kfree (encl); +return ret; + } file->private_data = encl;
@@ -33,31 +44,37 @@ static int sgx_open(struct inode *inode, struct file *file)static int sgx_release (struct inode *inode,struct file *file) {struct sgx_encl *encl = file->private_data; -struct sgx_encl_page *entry; -unsigned long index; - -xa_for_each (&encl->page_array, index, entry) { -if (entry->epc_page) { -sgx_free_epc_page (entry->epc_page); - encl->secs_child_cnt--; - entry->epc_page =NULL ; +struct sgx_encl_mm *encl_mm; + +/* +* Drain the remaining mm_list entries. At this point the list contains +* entries for processes, which have closed the enclave file but have +* not exited yet. The processes, which have exited, are gone from the +* list by sgx_mmu_notifier_release(). +*/ +for ( ; ; ) { +spin_lock (&encl->mm_lock); + +if (list_empty (&encl->mm_list)) { + encl_mm =NULL ; + }else { + encl_mm =list_first_entry (&encl->mm_list, + struct sgx_encl_mm, list); +list_del_rcu (&encl_mm->list); } -kfree (entry); - } +spin_unlock (&encl->mm_lock); -xa_destroy (&encl->page_array); +/* The enclave is no longer mapped by any mm. */ +if (!encl_mm) +break ; -if (!encl->secs_child_cnt && encl->secs.epc_page) { -sgx_free_epc_page (encl->secs.epc_page); - encl->secs.epc_page =NULL ; +synchronize_srcu (&encl->srcu); +mmu_notifier_unregister (&encl_mm->mmu_notifier, encl_mm->mm); +kfree (encl_mm); } -/* Detect EPC page leak's. */ -WARN_ON_ONCE (encl->secs_child_cnt); -WARN_ON_ONCE (encl->secs.epc_page); - -kfree (encl); +kref_put (&encl->refcount, sgx_encl_release);return 0 ; }
@@ -70,6 +87,10 @@ static int sgx_mmap(struct file *file, struct vm_area_struct *vma)if (ret)return ret; + ret =sgx_encl_mm_add (encl, vma->vm_mm); +if (ret) +return ret; + vma->vm_ops = &sgx_vm_ops; vma->vm_flags |=VM_PFNMAP |VM_DONTEXPAND |VM_DONTDUMP |VM_IO ; vma->vm_private_data = encl;
arch/x86/kernel/cpu/sgx/encl.c +479 -4
528 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/encl.h +51 -0
78 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/ioctl.c +85 -4
147 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/main.c +466 -0
517 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/sgx.h +13 -0
@@ -15,9 +15,17 @@#define SGX_MAX_EPC_SECTIONS 8#define SGX_EEXTEND_BLOCK_SIZE 256 +#define SGX_NR_TO_SCAN 16 +#define SGX_NR_LOW_PAGES 32 +#define SGX_NR_HIGH_PAGES 64 + +/* Pages, which are being tracked by the page reclaimer. */ +#define SGX_EPC_PAGE_RECLAIMER_TRACKED BIT(0)struct sgx_epc_page {unsigned int section; +unsigned int flags; +struct sgx_encl_page *owner;struct list_head list; };
@@ -33,6 +41,7 @@ struct sgx_epc_section {struct list_head page_list;struct list_head laundry_list;struct sgx_epc_page *pages; +unsigned long free_cnt;spinlock_t lock; };
@@ -61,4 +70,8 @@ static inline void *sgx_get_epc_virt_addr(struct sgx_epc_page *page)struct sgx_epc_page *__sgx_alloc_epc_page (void );void sgx_free_epc_page (struct sgx_epc_page *page); +void sgx_mark_page_reclaimable (struct sgx_epc_page *page); +int sgx_unmark_page_reclaimable (struct sgx_epc_page *page); +struct sgx_epc_page *sgx_alloc_epc_page (void *owner,bool reclaim); +#endif /* _X86_SGX_H */
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 22/24 x86/sgx: Add ptrace() support for the SGX driver
In reply to Jarkko SakkinenEnclave memory is normally inaccessible from outside the enclave. This makes enclaves hard to debug. However, enclaves can be put in a debug mode when they are being built. In debug enclaves data *can* be read and/or written by using the ENCLS[EDBGRD] and ENCLS[EDBGWR] functions.
This is obviously only for debugging and destroys all the protections afforded to normal enclaves. But, enclaves know their own debug status and can adjust their behavior appropriately.
Add a vm_ops->access() implementation which can be used to read and write memory inside debug enclaves. This is typically used via ptrace() APIs.
---
Changes from v39:
* Check only for SGX_ENCL_DEBUG in sgx_vma_access(), so that a debug enclave's memory can read and written at any phase of its life-cycle.
arch/x86/kernel/cpu/sgx/encl.c | 111 +++++++++++++++++++++++++++++++++ 1 file changed, 111 insertions(+)
arch/x86/kernel/cpu/sgx/encl.c +111 -0
@@ -272,10 +272,121 @@ static int sgx_vma_mprotect(struct vm_area_struct *vma, unsigned long start,return sgx_encl_may_map (vma->vm_private_data, start, end, newflags); } +static int sgx_encl_debug_read (struct sgx_encl *encl,struct sgx_encl_page *page, +unsigned long addr,void *data) +{ +unsigned long offset = addr & ~PAGE_MASK ; +int ret; + + + ret =__edbgrd (sgx_get_epc_virt_addr (page->epc_page) + offset, data); +if (ret) +return -EIO ; + +return 0 ; +} + +static int sgx_encl_debug_write (struct sgx_encl *encl,struct sgx_encl_page *page, +unsigned long addr,void *data) +{ +unsigned long offset = addr & ~PAGE_MASK ; +int ret; + + ret =__edbgwr (sgx_get_epc_virt_addr (page->epc_page) + offset, data); +if (ret) +return -EIO ; + +return 0 ; +} + +/* +* Load an enclave page to EPC if required, and take encl->lock. +*/ +static struct sgx_encl_page *sgx_encl_reserve_page (struct sgx_encl *encl, +unsigned long addr, +unsigned long vm_flags) +{ +struct sgx_encl_page *entry; + +for ( ; ; ) { +mutex_lock (&encl->lock); + + entry =sgx_encl_load_page (encl, addr, vm_flags); +if (PTR_ERR (entry) != -EBUSY ) +break ; + +mutex_unlock (&encl->lock); + } + +if (IS_ERR (entry)) +mutex_unlock (&encl->lock); + +return entry; +} + +static int sgx_vma_access (struct vm_area_struct *vma,unsigned long addr, +void *buf,int len,int write) +{ +struct sgx_encl *encl = vma->vm_private_data; +struct sgx_encl_page *entry =NULL ; +char data[sizeof (unsigned long )]; +unsigned long align; +int offset; +int cnt; +int ret =0 ; +int i; + +/* +* If process was forked, VMA is still there but vm_private_data is set +* to NULL. +*/ +if (!encl) +return -EFAULT ; + +if (!test_bit (SGX_ENCL_DEBUG , &encl->flags)) +return -EFAULT ; + +for (i =0 ; i < len; i += cnt) { + entry =sgx_encl_reserve_page (encl, (addr + i) &PAGE_MASK , + vma->vm_flags); +if (IS_ERR (entry)) { + ret =PTR_ERR (entry); +break ; + } + + align =ALIGN_DOWN (addr + i,sizeof (unsigned long )); + offset = (addr + i) & (sizeof (unsigned long ) -1 ); + cnt =sizeof (unsigned long ) - offset; + cnt =min (cnt, len - i); + + ret =sgx_encl_debug_read (encl, entry, align, data); +if (ret) + goto out; + +if (write) { +memcpy (data + offset, buf + i, cnt); + ret =sgx_encl_debug_write (encl, entry, align, data); +if (ret) + goto out; + }else { +memcpy (buf + i, data + offset, cnt); + } + +out: +mutex_unlock (&encl->lock); + +if (ret) +break ; + } + +return ret <0 ? ret : i; +} +const struct vm_operations_struct sgx_vm_ops = { .fault = sgx_vma_fault, .mprotect = sgx_vma_mprotect, .open = sgx_vma_open, + .access = sgx_vma_access, };/**
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 23/24 docs: x86/sgx: Document SGX kernel architecture
In reply to Jarkko SakkinenDocument the Intel SGX kernel architecture. The fine-grained architecture details can be looked up from Intel SDM Volume 3D.
# Co-developed-by: Sean Christopherson <[email protected]> # Signed-off-by: Sean Christopherson <[email protected]>
--- Documentation/x86/index.rst | 1 + Documentation/x86/sgx.rst | 211 ++++++++++++++++++++++++++++++++++++ 2 files changed, 212 insertions(+) create mode 100644 Documentation/x86/sgx.rst
Documentation/x86/index.rst +1 -0
@@ -33,3 +33,4 @@ x86-specific Documentation i386/index x86_64/index sva + sgx
Documentation/x86/sgx.rst new file +211 -0
211 lines not on this page · raw message
Signature · 1 line
2.27.0
Jarkko Sakkinen
maintainerPATCH v41 24/24 x86/sgx: Update MAINTAINERS
In reply to Jarkko SakkinenAdd the maintainer information for the SGX subsystem.
--- MAINTAINERS | 13 +++++++++++++ 1 file changed, 13 insertions(+)
MAINTAINERS +13 -0
@@ -9126,6 +9126,19 @@ F: Documentation/x86/intel_txt.rst F: arch/x86/kernel/tboot.c F: include/linux/tboot.h +INTEL SGX +M: Jarkko Sakkinen <[email protected]> +L: [email protected] +S: Supported +Q: https://patchwork.kernel.org/project/intel-sgx/list/ +T: git git://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-sgx.git +F: Documentation/x86/sgx.rst +F: arch/x86/entry/vdso/vsgx.S +F: arch/x86/include/uapi/asm/sgx.h +F: arch/x86/kernel/cpu/sgx/* +F: tools/testing/selftests/sgx/* +K: \bSGX_ + INTERCONNECT API M: Georgi Djakov <[email protected]> L: [email protected]
Signature · 1 line
2.27.0
Re: [PATCH v41 10/24] mm: Add 'mprotect' hook to struct vm_operations_struct
In reply to Jarkko SakkinenQuoted 47 lines · Jarkko Sakkinen
From: Sean Christopherson <[email protected]>
Background
==========1. SGX enclave pages are populated with data by copying from normal memory via
ioctl()(SGX_IOC_ENCLAVE_ADD_PAGES), which will be added later in this series.
2. It is desirable to be able to restrict those normal memory data sources. For instance, to ensure that the source data is executable before copying data to an executable enclave page.
3. Enclave page permissions are dynamic (just like normal permissions) and can be adjusted at runtime withmprotect().This creates a problem because the original data source may have long since vanished at the time when enclave page permissions are established (
mmap()ormprotect()).The solution (elsewhere in this series) is to force enclaves creators to declare their paging permission *intent* up front to the
ioctl(). This intent can be immediately compared to the source data???s mapping and rejected if necessary.The ???intent??? is also stashed off for later comparison with enclave PTEs. This ensures that any future mmap()/mprotect() operations performed by the enclave creator or done on behalf of the enclave can be compared with the earlier declared permissions.
Problem
=======There is an existing
mmap()hook which allows SGX to perform this permission comparison atmmap()time. However, there is no corresponding ->mprotect() hook.Solution
========Add a
vm_ops->mprotect()hook so thatmprotect()operations which are inconsistent with any page's stashed intent can be rejected by the driver.Cc Andrew Morton <[email protected]>Cc Matthew Wilcox <[email protected]>Cc Mel Gorman <[email protected]>
Quoted 3 lines
# Signed-off-by: Sean Christopherson <[email protected]>
Co-developed-by Jarkko Sakkinen <[email protected]>Signed-off-by Jarkko Sakkinen <[email protected]>
Signature · 2 lines
Mel Gorman SUSE Labs
Re: [PATCH v41 10/24] mm: Add 'mprotect' hook to struct vm_operations_struct
In reply to Jarkko SakkinenOn Fri, Nov 13, 2020 at 12:01:21AM +0200, Jarkko Sakkinen wrote:
Good morning, I hope the weekend is going well for everyone.
Quoted 1 line
From: Sean Christopherson <[email protected]>
We wish Sean well in whatever new avocation he has chosen.
Quoted 21 lines
Background
==========1. SGX enclave pages are populated with data by copying from normal memory via
ioctl()(SGX_IOC_ENCLAVE_ADD_PAGES), which will be added later in this series.
2. It is desirable to be able to restrict those normal memory data sources. For instance, to ensure that the source data is executable before copying data to an executable enclave page.
3. Enclave page permissions are dynamic (just like normal permissions) and can be adjusted at runtime withmprotect().This creates a problem because the original data source may have long since vanished at the time when enclave page permissions are established (
mmap()ormprotect()).The solution (elsewhere in this series) is to force enclaves creators to declare their paging permission *intent* up front to the
ioctl(). This intent can be immediately compared to the source data???s mapping and rejected if necessary.
Quoted 4 lines
The ???intent??? is also stashed off for later comparison with enclave PTEs. This ensures that any future mmap()/mprotect() operations performed by the enclave creator or done on behalf of the enclave can be compared with the earlier declared permissions.
The new mprotect hook in vm_operations_struct is indeed useful, as I will demonstrate in a subsequent patch for consideration. However, the officially stated intent of this version of the driver is to implement SGX1 semantics even on hardware (SGX2) that implements the instructions needed for Enclave Dynamic Memory Management (EDMM).
As a result, at this stage of the driver's development, the implementation that walks the page permission intents can be substituted with a simple denial of mmap and mprotect on an initialized enclave. With this prohibition in place, the hardware itself will enforce the page permission intents that were encoded when the enclave was loaded, thus making the subsequent scan irrelevant.
The following patch implements this functionality.
Dr. Greg
---------------------------------------------------------------------------
Subject: [PATCH] Unconditionally block permission changes on enclave memory.
In SGX there are two levels of memory protection, the classic page table mechanism and SGX hardware based page protections that are codified in the Enclave Page Cache Metadata. A successful memory access requires that both mechanisms agree that the access is permitted.
In the initial implementation of SGX (SGX1), the page permissions are immutable after the enclave is initialized. Even if classic page protections are modified via mprotect, any attempt to access enclave memory with alternative permissions will be blocked.
One of the architectural changes implemented in the second generation of SGX (SGX2) is the ability for page access permissions to be dynamically manipulated after the enclave is initialized. This requires coordination between trusted code running in the enclave and untrusted code using mprotect and special ring-0 instructions.
One of the security threats associated with SGX2 hardware is that enclave based code can conspire with its untrusted runtime to make executable enclave memory writable. This provides the opportunity for completely anonymous code execution that the operating system has no visibility into.
All that is needed to, simply, close this vulnerability is to eliminate the ability to call mprotect or mmap against the virtual memory range of an enclave after it is initialized. Any permission changes made prior to initialization that are inconsistent with the permissions codified in the enclave will cause initialization or execution of the enclave to fail.
--- arch/x86/kernel/cpu/sgx/encl.c | 50 +++++++++------------------------- 1 file changed, 13 insertions(+), 37 deletions(-)
arch/x86/kernel/cpu/sgx/encl.c +13 -37
@@ -212,27 +212,25 @@ static void sgx_vma_open(struct vm_area_struct *vma)* @end: upper bound of the address range, exclusive * @vm_flags: VMA flags * -* Iterate through the enclave pages contained within [@start, @end) to verify -* that the permissions requested by a subset of {VM_READ, VM_WRITE, VM_EXEC} -* does not contain any permissions that are not contained in the build time -* permissions of any of the enclave pages within the given address range. +* This function provides a method for determining whether or not mmap +* or mprotect can be invoked called on any pages in the virtual +* address range of an enclave. * -* An enclave creator must declare the strongest permissions that will be -* needed for each enclave page This ensures that mappings have the identical -* or weaker permissions that the earlier declared permissions. +* Since this driver is not designed to support Enclave Dynamic Memory +* Management (EDMM), any attempts to modify enclave memory map after +* the enclave is initialized are simply blocked. +* +* The function signature is left intact since future versions of the +* driver may implement verifications that the requested permission +* changes are consistent with the desire of the enclave author. * * Return: 0 on success, -EACCES otherwise */ int sgx_encl_may_map (struct sgx_encl *encl,unsigned long start,unsigned long end,unsigned long vm_flags) { -unsigned long vm_prot_bits = vm_flags & (VM_READ |VM_WRITE |VM_EXEC ); -struct sgx_encl_page *page; -unsigned long count =0 ;int ret =0 ; -XA_STATE (xas, &encl->page_array,PFN_DOWN (start)); -/* * Disallow READ_IMPLIES_EXEC tasks as their VMA permissions might * conflict with the enclave page permissions.
@@ -240,31 +238,9 @@ int sgx_encl_may_map(struct sgx_encl *encl, unsigned long start,if (current->personality &READ_IMPLIES_EXEC )return -EACCES ; -mutex_lock (&encl->lock); -xas_lock (&xas); -xas_for_each (&xas, page,PFN_DOWN (end -1 )) { -if (!page) -break ; - -if (~page->vm_max_prot_bits & vm_prot_bits) { - ret = -EACCES ; -break ; - } - -/* Reschedule on every XA_CHECK_SCHED iteration. */ -if (!(++count %XA_CHECK_SCHED )) { -xas_pause (&xas); -xas_unlock (&xas); -mutex_unlock (&encl->lock); - -cond_resched (); - -mutex_lock (&encl->lock); -xas_lock (&xas); - } - } -xas_unlock (&xas); -mutex_unlock (&encl->lock); +/* Disallow mapping on an initialized enclave. */ +if (test_bit (SGX_ENCL_INITIALIZED , &encl->flags)) + ret = -EACCES ;return ret; }
Signature · 14 lines
2.19.2 --------------------------------------------------------------------------- As always, Dr. Greg Wettstein, Ph.D, Worker Autonomously self-defensive Enjellic Systems Development, LLC IOT platforms and edge devices. 4206 N. 19th Ave. Fargo, ND 58102 PH: 701-281-1686 EMAIL: [email protected] ------------------------------------------------------------------------------ "For a successful technology, reality must take precedence over public relations, for nature cannot be fooled." -- Richard Feynmann
Re: [PATCH v41 10/24] mm: Add 'mprotect' hook to struct vm_operations_struct
In reply to Jarkko Sakkineninclude/linux/mm.h struct vm_operations_struct { · line 566
Quoted 10 lines · Jarkko Sakkinen
+++
b/include/linux/mm.hinclude/linux/mm.h +5
-0@@ -559,6 +559,13 @@ struct vm_operations_struct {void (*close)(struct vm_area_struct * area);int (*split)(struct vm_area_struct * area,unsigned long addr);int (*mremap)(struct vm_area_struct * area); +/* +* Called by mprotect() to make driver-specific permission +* checks before mprotect() is finalised. The VMA must not +* be modified. Returns 0 if eprotect() can proceed. +*/
This is the wrong place for this documentation, and it's absurdly specific to your implementation. It should be in Documentation/filesystems/locking.rst.
mm/mprotect.c static int do_mprotect_pkey(unsigned long start, size_t len, · line 629
Quoted 13 lines
mm/mprotect.c +9
-0+int (*mprotect)(struct vm_area_struct *vma,unsigned long start, +unsigned long end,unsigned long newflags); + +if (vma->vm_ops && vma->vm_ops->mprotect) + error = vma->vm_ops->mprotect (vma, nstart, tmp, newflags); +if (error) + goto out; + error =mprotect_fixup (vma, &prev, nstart, tmp, newflags);if (error) goto out; + nstart = tmp;
Spurious newline added.
Re: [PATCH v41 10/24] mm: Add 'mprotect' hook to struct vm_operations_struct
Quoted 15 lines · Matthew Wilcox
include/linux/mm.h struct vm_operations_struct { · line 566
Quoted 10 lines · Jarkko Sakkinen
+++
b/include/linux/mm.hinclude/linux/mm.h +5
-0@@ -559,6 +559,13 @@ struct vm_operations_struct {void (*close)(struct vm_area_struct * area);int (*split)(struct vm_area_struct * area,unsigned long addr);int (*mremap)(struct vm_area_struct * area); +/* +* Called by mprotect() to make driver-specific permission +* checks before mprotect() is finalised. The VMA must not +* be modified. Returns 0 if eprotect() can proceed. +*/ This is the wrong place for this documentation, and it's absurdly specific to your implementation. It should be in
Documentation/filesystems/locking.rst.
I'll let you and Mel duke that one out:
Quoted 1 line
As for 'locking.rst', I didn't even know that was there. It's also a _bit_ silly that we would depend on folks finding that for code like SGX that has nothing to do with filesystems. If we expect folks to update that, we need a comment spelling that out in the struct.
The comment also _looks_ reasonably generic to me. None of the parameters can be modified, so the impact on the core mm code must only be from the result of the return code, even if the handler does some other magic in addition to plain checks.
For one thing, I guess we could take the literal mention of "driver" out. vm_operations are certainly supplied by code that isn't a "driver" per se.
Quoted 7 lines
Quoted 7 lines
mm/mprotect.c +7
-0+int (*mprotect)(struct vm_area_struct *vma,unsigned long start, +unsigned long end,unsigned long newflags); + +if (vma->vm_ops && vma->vm_ops->mprotect) + error = vma->vm_ops->mprotect (vma, nstart, tmp, newflags); +if (error) + goto out;
Quoted 8 lines
mm/mprotect.c static int do_mprotect_pkey(unsigned long start, size_t len, · line 629
Quoted 6 lines
mm/mprotect.c +2
-0+ error =mprotect_fixup (vma, &prev, nstart, tmp, newflags);if (error) goto out; + nstart = tmp;Spurious newline added.
I don't actually think this is spurious. It ends up grouping the code into the logical chunks with the ->mprotect() and goto in one chunk and mprotect_fixup() and its goto in another. Without this newline, the two logical parts don't look separate.
It's kinda hard to see with just the diff context, though.
Re: [PATCH v41 10/24] mm: Add 'mprotect' hook to struct vm_operations_struct
Quoted 17 lines · Dave Hansen
Quoted 15 lines · Matthew Wilcox
include/linux/mm.h struct vm_operations_struct { · line 566
Quoted 10 lines · Jarkko Sakkinen
+++
b/include/linux/mm.hinclude/linux/mm.h +5
-0@@ -559,6 +559,13 @@ struct vm_operations_struct {void (*close)(struct vm_area_struct * area);int (*split)(struct vm_area_struct * area,unsigned long addr);int (*mremap)(struct vm_area_struct * area); +/* +* Called by mprotect() to make driver-specific permission +* checks before mprotect() is finalised. The VMA must not +* be modified. Returns 0 if eprotect() can proceed. +*/ This is the wrong place for this documentation, and it's absurdly specific to your implementation. It should be in
Documentation/filesystems/locking.rst.
Quoted 2 lines
I'll let you and Mel duke that one out:
I suggested placing the comment there to make it clear what the expected semantics of the hook was to reduce the chances of abuse or surprises. The hook does not affect locking so Documentation/filesystems/locking.rst didn't appear appropriate other than maybe adding a note there that it doesn't affect locks. The hook also is not expecting any filesystems-specific action that I aware of but a note could be added to the effect that filesystems should not need to take special action for it. Protections on the filesystem level are for the inode, I can't imagine what a filesystem would do with a protection change on the page table level but maybe I'm not particularly imaginative today.
Signature · 2 lines
Mel Gorman SUSE Labs
Borislav Petkov
maintainerQuoted 5 lines · Jarkko Sakkinen
Sean Christopherson is a major contributor to this series. However, he has left Intel and his @intel.com address will soon be bouncing. He does not have a email he wants us to substitute or put in .mailmap for now. To avoid subjecting everyone to bounces, we have commented out his tag lines in the commit messages.
Don't do that - there's a --suppress-cc=<category> cmdline switch to git-send-email for exactly those things.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteQuoted 8 lines · Borislav Petkov
Quoted 5 lines · Jarkko Sakkinen
Sean Christopherson is a major contributor to this series. However, he has left Intel and his @intel.com address will soon be bouncing. He does not have a email he wants us to substitute or put in .mailmap for now. To avoid subjecting everyone to bounces, we have commented out his tag lines in the commit messages.
Don't do that - there's a --suppress-cc=<category> cmdline switch to git-send-email for exactly those things.
That works when there is something universal across the set, like if Sean Signed-off-by on each patch and we didn't have any other SoB's. Sean is also mentioned in at least one of five different tags:
From: Sean Christopherson <[email protected]>
The bounces aren't the end of the world, they're just annoying.
Borislav Petkov
maintainerQuoted 3 lines · Dave Hansen
That works when there is something universal across the set, like if Sean Signed-off-by on each patch and we didn't have any other SoB's. Sean is also mentioned in at least one of five different tags:
So?
You git-format-patch, build the CC-list and supply it with --cc-cmd or whatever scripting you have and do --suppress-cc=all as the last switch.
Quoted 1 line
The bounces aren't the end of the world, they're just annoying.
And I have to go edit every patch by hand to remove those comments again. No, bounces happen all the time and we ignore them simply. Can't fix them all.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH v41 12/24] x86/sgx: Add SGX_IOC_ENCLAVE_CREATE
In reply to a message not in the archiveHillf, I noticed that you removed a bunch of folks from cc, including me. Was there a reason for that? I haven't been seeing your feedback on these patches at all.
Quoted 12 lines · Hillf Danton
arch/x86/kernel/cpu/sgx/ioctl.c line 110
Quoted 7 lines · On Fri, 13 Nov 2020 00:01:23 +0200 Jarkko Sakkinen wrote:
arch/x86/kernel/cpu/sgx/ioctl.c new file +7
-0+long sgx_ioctl (struct file *filep,unsigned int cmd,unsigned long arg) +{ +struct sgx_encl *encl = filep->private_data; +int ret; + +if (test_and_set_bit (SGX_ENCL_IOCTL , &encl->flags)) +return -EBUSY ;Looks like
encl->ioctl_mutexis needed to exlusively serialize concurrent ioctl threads and makeencl->flagsfree of the duty. Plus it can cut the confusing EBUSY in userspace as it is not a critical path in any form.
I actually think the -EBUSY might be a bit too nice. This is a *bad* condition that userspace shouldn't be hitting.
Sean had a great explanation of this in a private mail:
Quoted 11 lines
Reclaiming (i.e. swapping) pages out of an enclave can be done while an enclave is being built. Reclaiming involves ENCLS, which needs to be serialized for a given enclave, i.e. reclaiming pages needs to take
encl->lock. To help adjust to EPC pressure, reclaim is automatically performed when allocating an EPC page, i.e. is triggered by ioctls. Holdingencl->lockfor the entireioctl()will thus deadlock if an enclave reclaims from itself.There are other ways to solve the deadlock problem, e.g. only reclaim from workers and never from process context, but there are other motivations for the atomic shenanigans (see below).
Quoted 8 lines
ENCLS instructions must be serialized for a given enclave, but holding
encl->lockfor an entireioctl()will result in deadlock due to an enclave triggering reclaim on itself.Building an enclave must also be serialized, i.e. userspace can't queue up EADD on multiple threads, because the order in which pages are added to an enclave affects the measurement. In other words, rejecting the
ioctl()as opposed to waiting on a lock is also desirable.
Sounds like we need should follow up with an add-on patch to get some of that into a comment.
Shuah Khan
maintainerRe: [PATCH v41 20/24] selftests/x86: Add a selftest for SGX
In reply to Jarkko SakkinenQuoted 46 lines · Jarkko Sakkinen
Add a selftest for SGX. It is a trivial test where a simple enclave copies one 64-bit word of memory between two memory locations, but ensures that all SGX hardware and software infrastructure is functioning.
Cc Shuah Khan <[email protected]>Signed-off-by Jarkko Sakkinen <[email protected]>---
Changes from v40:
* Remove $(OUTPUT)/test_encl.elf fromTEST_CUSTOM_PROGS, as otherwiserun_teststries to execute it. Add it as a build dependency.
* Use the correct device path,/dev/sgx_enclave, instead of/dev/sgx/enclave.
* Return kselftest framework expected return codes.tools/testing/selftests/Makefile | 1 + tools/testing/selftests/sgx/.gitignore | 2 + tools/testing/selftests/sgx/Makefile | 53 +++ tools/testing/selftests/sgx/call.S | 44 ++ tools/testing/selftests/sgx/defines.h | 21 + tools/testing/selftests/sgx/load.c | 277 +++++++++++++ tools/testing/selftests/sgx/main.c | 246 +++++++++++ tools/testing/selftests/sgx/main.h | 38 ++ tools/testing/selftests/sgx/sigstruct.c | 391 ++++++++++++++++++ tools/testing/selftests/sgx/test_encl.c | 20 + tools/testing/selftests/sgx/test_encl.lds | 40 ++ .../selftests/sgx/test_encl_bootstrap.S | 89 ++++ 12 files changed, 1222 insertions(+)create mode 100644
tools/testing/selftests/sgx/.gitignorecreate mode 100644tools/testing/selftests/sgx/Makefilecreate mode 100644tools/testing/selftests/sgx/call.Screate mode 100644tools/testing/selftests/sgx/defines.hcreate mode 100644tools/testing/selftests/sgx/load.ccreate mode 100644tools/testing/selftests/sgx/main.ccreate mode 100644tools/testing/selftests/sgx/main.hcreate mode 100644tools/testing/selftests/sgx/sigstruct.ccreate mode 100644tools/testing/selftests/sgx/test_encl.ccreate mode 100644tools/testing/selftests/sgx/test_encl.ldscreate mode 100644tools/testing/selftests/sgx/test_encl_bootstrap.Stools/testing/selftests/Makefile +0
-0
tools/testing/selftests/Makefile TARGETS += user · line 72
Quoted 5 lines
tools/testing/selftests/Makefile +1
-0@@ -68,6 +68,7 @@ TARGETS += user TARGETS += vm TARGETS += x86 TARGETS += zram +TARGETS += sgx #Please keep the TARGETS list alphabetically sorted
Please keep the list sorted alphabetically as stated in the comment above.
Quoted 27 lines
tools/testing/selftests/Makefile +27
-0+} + +int main(int argc, char *argv[], char *envp[]) +{ + struct sgx_enclave_run run; + struct vdso_symtab symtab; + Elf64_Sym *eenter_sym; + uint64_t result = 0; + struct encl encl; + unsigned int i; + void *addr; + int ret; + + memset(&run, 0, sizeof(run)); + + if (!encl_load("test_encl.elf", &encl)) { + encl_delete(&encl); + ksft_exit_skip("cannot load enclaves\n"); + } + + if (!encl_measure(&encl)) + goto err; + + if (!encl_build(&encl)) + goto err; + + /*
tools/testing/selftests/Makefile TARGETS += user
Quoted 10 lines
tools/testing/selftests/Makefile +10
-0+ * An enclave consumer only must do this. + */ + for (i = 0; i < encl.nr_segments; i++) { + struct encl_segment *seg = &encl.segment_tbl[i]; + + addr = mmap((void *)encl.encl_base + seg->offset, seg->size, + seg->prot, MAP_SHARED | MAP_FIXED, encl.fd, 0); + if (addr == MAP_FAILED) { + fprintf(stderr, "mmap() failed, errno=%d.\n", errno); + exit(1);
This should be KSFT_FAIL.
thanks,
-- Shuah
Re: [PATCH v41 05/24] x86/sgx: Initialize metadata for Enclave Page Cache (EPC) sections
In reply to a message not in the archiveQuoted 23 lines · Hillf Danton
Quoted 22 lines · On Fri, 13 Nov 2020 00:01:16 +0200 Jarkko Sakkinen wrote:
+ */
(quoted diff) +21
-0+static void sgx_sanitize_section(struct sgx_epc_section *section) +{ + struct sgx_epc_page *page; + LIST_HEAD(dirty); + int ret; + + while (!list_empty(§ion->laundry_list)) { + if (kthread_should_stop()) + return; + + spin_lock(§ion->lock); + + page = list_first_entry(§ion->laundry_list, + struct sgx_epc_page, list); + + ret = __eremove(sgx_get_epc_virt_addr(page)); + if (!ret) + list_move(&page->list, §ion->page_list); + else + list_move_tail(&page->list, &dirty); +
Quoted 8 lines
Review
Quoted 6 lines
(quoted diff) +6
-0+ spin_unlock(§ion->lock); + + cond_resched(); + } + + list_splice(&dirty, §ion->laundry_list);Move list splice into the section under
section->lock.
The naming, commenting and changelogs could be better here. But, I think the code is correct.
section->lock actually only protects ->page_list.
->laundry_list is initialized in core code, but after that is only used by ksgxd and is effectively a thread-local structure.
I can think of a few other ways of doing this so that, for instance, laundry_list was a thread-local structure in ksgxd that is freed after initialization and sanitizing. But, this is pretty simple, although under-documented, and wastes a list_head worth of space per section at runtime.
Quoted 9 lines
Quoted 1 line
+}
[...]
Review
Quoted 2 lines
(quoted diff) +2
-0+struct sgx_epc_page { + unsigned int section;To make the sgx page naturally packed, add a small pad to match both
sizeof(struct list_head)andX86_64. Feel free to turn back on the pad OTOH to save memory.
You make a good point: it's pretty obvious that the current code is space-optimized. That doesn't seem like a bad thing to me, though.
Re: [PATCH v41 11/24] x86/sgx: Add SGX misc driver interface
In reply to a message not in the archiveQuoted 14 lines · Hillf Danton
On Fri, 13 Nov 2020 00:01:22 +0200 Jarkko Sakkinen wrote:
(quoted diff) +13
-0+ +static unsigned long sgx_get_unmapped_area(struct file *file, + unsigned long addr, + unsigned long len, + unsigned long pgoff, + unsigned long flags) +{ + if ((flags & MAP_TYPE) == MAP_PRIVATE) + return -EINVAL; + + if (flags & MAP_FIXED) + return addr; +
Quoted 2 lines
MAP_FIXEDis checked inarch_get_unmapped_area()along with others, so better to check it always there.
In the whole tangle of get_unmapped_area() functions, it wasn't patently obvious to me that MAP_FIXED functionality is guaranteed to be present in the higher-level functions.
There are also a fair number of these fops->get_unmapped_area() instances that have the same MAP_FIXED line. Are in need of fixups too?
Or are you suggesting that since SGX is x86-only, it can depend on the
x86 arch_get_unmapped_area() code to continue to have this MAP_FIXED functionality?
PATCH 1/1 x86/sgx: clarify 'laundry_list' locking
In reply to Jarkko SakkinenFrom: Dave Hansen <[email protected]>
Short Version:
The SGX section->laundry_list structure is effectively thread-local, but declared next to some shared structures. Its semantics are clear as mud. Fix that. No functional changes. Compile tested only.
Long Version:
The SGX hardware keeps per-page metadata. This can provide things like permissions, integrity and replay protection. It also prevents things like having an enclave page mapped multiple times or shared between enclaves.
But, that presents a problem for kexec()'d kernels (or any other kernel that does not run immediately after a hardware reset). This is because the last kernel may have been rude and forgotten to reset pages, which would trigger the the "shared page" sanity check.
To fix this, the SGX code "launders" the pages by running the EREMOVE instruction on all pages at boot. This is slow and can take a long time, so it is performed off in the SGX-specific ksgxd instead of being synchronous at boot. The init code hands the list of pages to launder in a per-SGX-section list: ->laundry_list. The only code to touch this list is the init code and ksgxd. This means that no locking is necessary for ->laundry_list.
However, a lock is required for section->page_list, which is accessed while creating enclaves and by ksgxd. This lock (section->lock is acquired by ksgxd while also processing ->laundry_list. It is easy to confuse the purpose of the locking as being for ->laundry_list and ->page_list.
Rename ->laundry_list to ->init_laundry_list to make it clear that this is not normally used at runtime. Also add some comments clarifying the locking, and reorganize 'sgx_epc_section' to put 'lock' near the things it protects.
Note: init_laundry_list is 128 bytes of wasted space at runtime. It could theoretically be dynamically allocated and then freed after the laundering process. But, I suspect it would take nearly 128 bytes of extra instructions to do that.
---
b/arch/x86/kernel/cpu/sgx/main.c | 14 ++++++++------ b/arch/x86/kernel/cpu/sgx/sgx.h | 15 ++++++++++++--- 2 files changed, 20 insertions(+), 9 deletions(-)
arch/x86/kernel/cpu/sgx/main.c renamed from arch/x86/kernel/cpu/sgx/main.c~sgx-laundry-comments +8 -6
@@ -36,13 +36,15 @@ static void sgx_sanitize_section(structLIST_HEAD (dirty);int ret; -while (!list_empty (§ion->laundry_list)) { +/* init_laundry_list is thread-local, no need for a lock: */ +while (!list_empty (§ion->init_laundry_list)) {if (kthread_should_stop ())return ; +/* needed for access to ->page_list: */ spin_lock (§ion->lock); - page =list_first_entry (§ion->laundry_list, + page =list_first_entry (§ion->init_laundry_list, struct sgx_epc_page, list); ret =__eremove (sgx_get_epc_virt_addr (page));
@@ -56,7 +58,7 @@ static void sgx_sanitize_section(structcond_resched (); } -list_splice (&dirty, §ion->laundry_list); +list_splice (&dirty, §ion->init_laundry_list); }static bool sgx_reclaimer_age (struct sgx_epc_page *epc_page)
@@ -418,7 +420,7 @@ static int ksgxswapd(void *p)sgx_sanitize_section (&sgx_epc_sections[i]);/* Should never happen. */ -if (!list_empty (&sgx_epc_sections[i].laundry_list)) +if (!list_empty (&sgx_epc_sections[i].init_laundry_list))WARN (1 ,"EPC section %d has unsanitized pages.\n" , i); }
@@ -632,13 +634,13 @@ static bool __init sgx_setup_epc_section section->phys_addr = phys_addr;spin_lock_init (§ion->lock);INIT_LIST_HEAD (§ion->page_list); -INIT_LIST_HEAD (§ion->laundry_list); +INIT_LIST_HEAD (§ion->init_laundry_list);for (i =0 ; i < nr_pages; i++) { section->pages[i].section = index; section->pages[i].flags =0 ; section->pages[i].owner =NULL ; -list_add_tail (§ion->pages[i].list, §ion->laundry_list); +list_add_tail (§ion->pages[i].list, §ion->init_laundry_list); } section->free_cnt = nr_pages;
arch/x86/kernel/cpu/sgx/sgx.h renamed from arch/x86/kernel/cpu/sgx/sgx.h~sgx-laundry-comments +12 -3
@@ -34,15 +34,24 @@ struct sgx_epc_page {* 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. +* +* 'lock' must be held before accessing 'page_list' or 'free_cnt'. */ 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; -unsigned long free_cnt; +spinlock_t lock; +struct list_head page_list; +unsigned long free_cnt; + +/* +* Pages which need EREMOVE run on them before they can be +* used. Only safe to be accessed in ksgxd and init code. +* Not protected by locks. +*/ +struct list_head init_laundry_list; };extern struct sgx_epc_section sgx_epc_sections[SGX_MAX_EPC_SECTIONS ];
_
Re: [PATCH v41 12/24] x86/sgx: Add SGX_IOC_ENCLAVE_CREATE
In reply to Dave HansenQuoted 10 lines · Dave Hansen
Quoted 8 lines
ENCLS instructions must be serialized for a given enclave, but holding
encl->lockfor an entireioctl()will result in deadlock due to an enclave triggering reclaim on itself.Building an enclave must also be serialized, i.e. userspace can't queue up EADD on multiple threads, because the order in which pages are added to an enclave affects the measurement. In other words, rejecting the
ioctl()as opposed to waiting on a lock is also desirable.Sounds like we need should follow up with an add-on patch to get some of that into a comment.
Jarkko, first of all, let's rename:
SGX_ENCL_IOCTL -> SGX_ENCL_IOCTL_LOCK
If it walks like a duck and quacks like a duck...
Sean had a good example of examples of how EADD could go wrong with multiple threads. Were there more good examples we could stick in a changelog? I seem to recall that there are more than a few SGX instructions don't even work in parallel and require software synchronization. Could we get a list or at least a few more good examples?
I also think we should be much more assertive about multiple ioctl() callers:
/* Multi-threaded enclave management is invalid and unsafe: */ if (test_and_set_bit(SGX_ENCL_IOCTL_LOCK, &encl->flags)) return -EINVAL;
-EBUSY is saying "everything is OK, just busy, please try again later."
-EINVAL is saying, "userspace, you screwed up".
Also, does SGX_ENCL_IOCTL_LOCK provide serialization for anything other than the *hardware* instructions? I couldn't find much, although:
encl->attributes_mask |= SGX_ATTR_PROVISIONKEY;
seems to be lacking any other serialization.
sgx_encl_create() also seems like it has no other locking and relies on SGX_ENCL_IOCTL_LOCK for sanity.
Borislav Petkov
maintainerRe: [PATCH v41 20/24] selftests/x86: Add a selftest for SGX
In reply to Shuah KhanQuoted 2 lines · Shuah Khan
Please keep the list sorted alphabetically as stated in the comment above.
Done.
Quoted 1 line
This should be
KSFT_FAIL.
and done.
Thx.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteBorislav Petkov
maintainerRe: [PATCH v41 19/24] x86/vdso: Implement a vDSO for Intel SGX enclave call
In reply to Jarkko Sakkinenarch/x86/entry/vdso/Makefile VDSO32-$(CONFIG_IA32_EMULATION) := y · line 30
Quoted 9 lines · Jarkko Sakkinen
arch/x86/entry/vdso/Makefile +1
-0@@ -27,6 +27,7 @@ VDSO32-$(CONFIG_IA32_EMULATION) := y vobjs-y := vdso-note.o vclock_gettime.o vgetcpu.o vobjs32-y := vdso32/note.o vdso32/system_call.o vdso32/sigreturn.o vobjs32-y += vdso32/vclock_gettime.o +vobjs-$(VDSO64-y) += vsgx.o
Why?
This needs to be CONFIG_X86_SGX as you need this vdso functionality only when SGX is enabled.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteJarkko Sakkinen
maintainerRe: [PATCH v41 12/24] x86/sgx: Add SGX_IOC_ENCLAVE_CREATE
In reply to Dave HansenQuoted 3 lines · Dave Hansen
Hillf, I noticed that you removed a bunch of folks from cc, including me. Was there a reason for that? I haven't been seeing your feedback on these patches at all.
I used the same script as for previous versions as '--cc-cmd', which simply outputs a static text file. Zero differences what I've done previously:
git send-email [email protected] --cc-cmd ../patches/cc-list.sh --cc [email protected] --to [email protected] --to [email protected] ~/Desktop/sgx-v41-fixed/*.patch
/Jarkko
Borislav Petkov
maintainerRe: [PATCH v41 20/24] selftests/x86: Add a selftest for SGX
In reply to Jarkko SakkinenQuoted 79 lines · Jarkko Sakkinen
tools/testing/selftests/sgx/load.c new file +79
-0+bool encl_load (const char *path,struct encl *encl) +{ +Elf64_Phdr *phdr_tbl; +off_t src_offset; +Elf64_Ehdr *ehdr; +int i, j; +int ret; + +memset (encl,0 ,sizeof (*encl)); + + ret =open ("/dev/sgx_enclave" ,O_RDWR ); +if (ret <0 ) { +fprintf (stderr,"Unable to open /dev/sgx_enclave\n" ); + goto err; + } + + encl->fd = ret; + +if (!encl_map_bin (path, encl)) + goto err; + + ehdr = encl->bin; + phdr_tbl = encl->bin + ehdr->e_phoff; + +for (i =0 ; i < ehdr->e_phnum; i++) { +Elf64_Phdr *phdr = &phdr_tbl[i]; + +if (phdr->p_type ==PT_LOAD ) + encl->nr_segments++; + } + + encl->segment_tbl =calloc (encl->nr_segments, +sizeof (struct encl_segment )); +if (!encl->segment_tbl) + goto err; + +for (i =0 , j =0 ; i < ehdr->e_phnum; i++) { +Elf64_Phdr *phdr = &phdr_tbl[i]; +unsigned int flags = phdr->p_flags; +struct encl_segment *seg; + +if (phdr->p_type !=PT_LOAD ) +continue ; + + seg = &encl->segment_tbl[j]; + +if (!!(flags & ~(PF_R |PF_W |PF_X ))) { +fprintf (stderr, +"%d has invalid segment flags 0x%02x.\n" , i, + phdr->p_flags); + goto err; + } + +if (j ==0 && flags != (PF_R |PF_W )) { +fprintf (stderr, +"TCS has invalid segment flags 0x%02x.\n" , + phdr->p_flags); + goto err; + } + +if (j ==0 ) { + src_offset = (phdr->p_offset &PAGE_MASK ) - src_offset; + + seg->prot =PROT_READ |PROT_WRITE ; + seg->flags =SGX_PAGE_TYPE_TCS <<8 ; + }else { + seg->prot = (phdr->p_flags &PF_R ) ?PROT_READ :0 ; + seg->prot |= (phdr->p_flags &PF_W ) ?PROT_WRITE :0 ; + seg->prot |= (phdr->p_flags &PF_X ) ?PROT_EXEC :0 ; + seg->flags = (SGX_PAGE_TYPE_REG <<8 ) | seg->prot; + } + + seg->offset = (phdr->p_offset &PAGE_MASK ) - src_offset; + seg->size = (phdr->p_filesz +PAGE_SIZE -1 ) &PAGE_MASK ; + +printf ("0x%016lx 0x%016lx 0x%02x\n" , seg->offset, seg->size, + seg->prot); + + j++;
tools/testing/selftests/sgx/load.c line 215
Quoted 10 lines
tools/testing/selftests/sgx/load.c new file +10
-0+ } + +assert (j == encl->nr_segments); + + encl->src = encl->bin + src_offset; + encl->src_size = encl->segment_tbl[j -1 ].offset + + encl->segment_tbl[j -1 ].size; + +for (encl->encl_size =4096 ; encl->encl_size < encl->src_size; ) + encl->encl_size <<=1 ;
Something's fishy. That selftest fails with
mmap: Cannot allocate memory
I sprinkled some printfs at this size computation above and here's what it says:
0x00007fdd3b4ca190 0x0000000000002000 0x03 0x00007fdd3b4cc190 0x0000000000001000 0x05 0x00007fdd3b4cd190 0x0000000000003000 0x03encl_load: encl->nr_segments: 3encl_load: seg2 offset: 0x7fdd3b4cd190, seg2 size: 12288encl_load: encl_size: 140737488355328, src_size: 140588159402384encl_map_area: encl_size: 140737488355328
mmap: Cannot allocate memory
src_size is computed by adding the offset and size of the last segment which is at index 2.
The loop computes encl_size to 0x0000800000000000 then and mmap tries to map double that in encl_map_area(). Looks like too much to me too.
What's up?
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteJarkko Sakkinen
maintainerRe: [PATCH v41 12/24] x86/sgx: Add SGX_IOC_ENCLAVE_CREATE
In reply to a message not in the archiveQuoted 14 lines · Hillf Danton
arch/x86/kernel/cpu/sgx/ioctl.c line 110
Quoted 8 lines · On Fri, 13 Nov 2020 00:01:23 +0200 Jarkko Sakkinen wrote:
arch/x86/kernel/cpu/sgx/ioctl.c new file +7
-0+long sgx_ioctl (struct file *filep,unsigned int cmd,unsigned long arg) +{ +struct sgx_encl *encl = filep->private_data; +int ret; + +if (test_and_set_bit (SGX_ENCL_IOCTL , &encl->flags)) +return -EBUSY ;Looks like
encl->ioctl_mutexis needed to exlusively serialize concurrent ioctl threads and makeencl->flagsfree of the duty. Plus it can cut the confusing EBUSY in userspace as it is not a critical path in any form.
The reason it is there was lock juggling with sgx_encl_grow() [*].
Andd since you never should use these ioctl's in parallel so why not explicitly signal it to the user space?
[*] https://lore.kernel.org/linux-sgx/[email protected]/
/Jarkko
Jarkko Sakkinen
maintainerRe: [PATCH v41 12/24] x86/sgx: Add SGX_IOC_ENCLAVE_CREATE
In reply to Dave HansenQuoted 16 lines · Dave Hansen
Quoted 10 lines · Dave Hansen
Quoted 8 lines
ENCLS instructions must be serialized for a given enclave, but holding
encl->lockfor an entireioctl()will result in deadlock due to an enclave triggering reclaim on itself.Building an enclave must also be serialized, i.e. userspace can't queue up EADD on multiple threads, because the order in which pages are added to an enclave affects the measurement. In other words, rejecting the
ioctl()as opposed to waiting on a lock is also desirable.Sounds like we need should follow up with an add-on patch to get some of that into a comment.
Jarkko, first of all, let's rename:
SGX_ENCL_IOCTL -> SGX_ENCL_IOCTL_LOCK
Quoted 7 lines
If it walks like a duck and quacks like a duck...
Sean had a good example of examples of how EADD could go wrong with multiple threads. Were there more good examples we could stick in a changelog? I seem to recall that there are more than a few SGX instructions don't even work in parallel and require software synchronization. Could we get a list or at least a few more good examples?
It does not need a specific example. A cryptographic measurement requires always a strict ordering. Any parallel use is a good example.
Quoted 9 lines
I also think we should be much more assertive about multiple
ioctl()callers:/* Multi-threaded enclave management is invalid and unsafe: */ if (test_and_set_bit(SGX_ENCL_IOCTL_LOCK, &encl->flags)) return -EINVAL;
-EBUSYis saying "everything is OK, just busy, please try again later."
-EINVALis saying, "userspace, you screwed up".
Yeah, it is invalid use of the API. I'll change it to -EINVAL.
Quoted 9 lines
Also, does
SGX_ENCL_IOCTL_LOCKprovide serialization for anything other than the *hardware* instructions? I couldn't find much, although:encl->attributes_mask |= SGX_ATTR_PROVISIONKEY;seems to be lacking any other serialization.
sgx_encl_create()also seems like it has no other locking and relies onSGX_ENCL_IOCTL_LOCKfor sanity.
Yeah, those ioctl's take advantage of the flag.
/Jarkko
Jarkko Sakkinen
maintainerRe: [PATCH v41 12/24] x86/sgx: Add SGX_IOC_ENCLAVE_CREATE
In reply to a message not in the archiveQuoted 7 lines · Hillf Danton
Quoted 3 lines · On Mon, 16 Nov 2020 09:54:47 -0800 Dave Hansen wrote:
Hillf, I noticed that you removed a bunch of folks from cc, including me.
I would have not done that if I noted Mr. TLB on the cc list, sigh.
Quoted 8 lines
Quoted 1 line
Was there a reason for that?
Mainly for avoiding sina's spam detection otherwise it would take another 24 hours to send the same mail out.
Quoted 1 line
I haven't been seeing your feedback on these patches at all.
My mail address may not survive spam scan at vger.kernel.org.
Ah, sorry we were talking about your response :-) I was worried that I did something wrong when sending the patch set.
/Jarkko
Jarkko Sakkinen
maintainerRe: [PATCH v41 06/24] x86/mm: x86/sgx: Signal SIGSEGV with PF_SGX
In reply to a message not in the archiveQuoted 57 lines · Hillf Danton
On Fri, 13 Nov 2020 00:01:17 +0200
Quoted 56 lines
From: Sean Christopherson <[email protected]>
The x86 architecture has a set of page fault error codes. These indicate things like whether the fault occurred from a write, or whether it originated in userspace.
The SGX hardware architecture has its own per-page memory management metadata (EPCM) [*] and hardware which is separate from the normal x86 MMU. The architecture has a new page fault error code:
PF_SGX. This new error code bit is set whenever a page fault occurs as the result of the SGX MMU.These faults occur for a variety of reasons. For instance, an access attempt to enclave memory from outside the enclave causes a
PF_SGXfault.PF_SGXwould also be set for permission conflicts, such as if a write to an enclave page occurs and the page is marked read-write in the x86 page tables but is read-only in the EPCM.These faults do not always indicate errors, though. SGX pages are encrypted with a key that is destroyed at hardware reset, including suspend. Throwing a SIGSEGV allows user space software to react and recover when these events occur.
Include
PF_SGXin the PF error codes list and throw SIGSEGV when it is encountered.[*] Intel SDM: 36.5.1 Enclave Page Cache Map (EPCM)
# Signed-off-by: Sean Christopherson <[email protected]>
Signed-off-by Jarkko Sakkinen <[email protected]>--- arch/x86/include/asm/trap_pf.h | 1 + arch/x86/mm/fault.c | 12 ++++++++++++ 2 files changed, 13 insertions(+)arch/x86/include/asm/trap_pf.h +1
-0@@ -19,6 +19,7 @@ enum x86_pf_error_code {X86_PF_RSVD =1 <<3 ,X86_PF_INSTR =1 <<4 ,X86_PF_PK =1 <<5 , + X86_PF_SGX = 1 << 15, };#endif /* _ASM_X86_TRAP_PF_H */ arch/x86/mm/fault.c +0
-0@@ -1101,6 +1101,18 @@ access_error(unsigned long error_code, struct vm_area_struct *vma)if (error_code &X86_PF_PK )return 1 ;
Quoted 12 lines
arch/x86/mm/fault.c access_error(unsigned long error_code, struct vm_area_struct *vma) · line 1112
Quoted 9 lines
arch/x86/mm/fault.c +9
-0+/* +* SGX hardware blocked the access. This usually happens +* when the enclave memory contents have been destroyed, like +* after a suspend/resume cycle. In any case, the kernel can't +* fix the cause of the fault. Handle the fault as an access +* error even in cases where no actual access violation +* occurred. This allows userspace to rebuild the enclave in +* response to the signal. +*/ Given SIGSEGV, it helps much understand
PF_SGXto specify the rebuild in userspace a bit more.
I'm sorry but I'm not exactly sure what you are suggesting.
/Jarkko
Jarkko Sakkinen
maintainerRe: [PATCH v41 09/24] x86/sgx: Add SGX page allocator functions
In reply to a message not in the archiveQuoted 88 lines · Hillf Danton
Quoted 87 lines · On Fri, 13 Nov 2020 00:01:20 +0200 Jarkko Sakkinen wrote:
The previous patch initialized a simple SGX page allocator. Add functions for runtime allocation and free.
This allocator and its algorithms are as simple as it gets. They do a linear search across all EPC sections and find the first free page. They are not NUMA aware and only hand out individual pages. The SGX hardware does not support large pages, so something more complicated like a buddy allocator is unwarranted.
The free function (
sgx_free_epc_page()) implicitly calls ENCLS[EREMOVE], which returns the page to the uninitialized state. This ensures that the page is ready for use at the next allocation.# Co-developed-by: Sean Christopherson <[email protected]> # Signed-off-by: Sean Christopherson <[email protected]>
Signed-off-by Jarkko Sakkinen <[email protected]>--- arch/x86/kernel/cpu/sgx/main.c | 65 ++++++++++++++++++++++++++++++++++ arch/x86/kernel/cpu/sgx/sgx.h | 3 ++ 2 files changed, 68 insertions(+)arch/x86/kernel/cpu/sgx/main.c +56
-0@@ -85,6 +85,71 @@ static bool __init sgx_page_reclaimer_init(void)return true; } +static struct sgx_epc_page *__sgx_alloc_epc_page_from_section (struct sgx_epc_section *section) +{ +struct sgx_epc_page *page; + +spin_lock (§ion->lock); + +if (list_empty (§ion->page_list)) { +spin_unlock (§ion->lock); +return NULL ; + } + + page = list_first_entry(§ion->page_list, struct sgx_epc_page, list); +list_del_init (&page->list); + +spin_unlock (§ion->lock); +return page; +} + +/** +* __sgx_alloc_epc_page() - Allocate an EPC page +* +* Iterate through EPC sections and borrow a free EPC page to the caller. When a +* page is no longer needed it must be released with sgx_free_epc_page(). +* +* Return: +* an EPC page, +* -errno on error +*/ +struct sgx_epc_page *__sgx_alloc_epc_page (void ) +{ +struct sgx_epc_section *section; +struct sgx_epc_page *page; +int i; + +for (i =0 ; i < sgx_nr_epc_sections; i++) { + section = &sgx_epc_sections[i]; + + page =__sgx_alloc_epc_page_from_section (section); +if (page) +return page; + } + +return ERR_PTR (-ENOMEM ); +} + +/** +* sgx_free_epc_page() - Free an EPC page +* @page: an EPC page +* +* Call EREMOVE for an EPC page and insert it back to the list of free pages. +*/ +void sgx_free_epc_page (struct sgx_epc_page *page) +{ +struct sgx_epc_section *section = &sgx_epc_sections[page->section]; +int ret; +
Quoted 8 lines
arch/x86/kernel/cpu/sgx/main.c static bool __init sgx_page_reclaimer_init(void) · line 149
Quoted 6 lines
arch/x86/kernel/cpu/sgx/main.c +6
-0+ ret =__eremove (sgx_get_epc_virt_addr (page)); +if (WARN_ONCE (ret,"EREMOVE returned %d (0x%x)" , ret, ret)) +return ; + +spin_lock (§ion->lock); +list_add_tail (&page->list, §ion->page_list);Add head in favor of allocators coming before LLC becomes cold.
Nice suggestion, thank you.
/Jarkko
Jarkko Sakkinen
maintainerRe: [PATCH v41 10/24] mm: Add 'mprotect' hook to struct vm_operations_struct
In reply to Mel GormanQuoted 52 lines · Mel Gorman
Quoted 47 lines · Jarkko Sakkinen
From: Sean Christopherson <[email protected]>
Background
==========1. SGX enclave pages are populated with data by copying from normal memory via
ioctl()(SGX_IOC_ENCLAVE_ADD_PAGES), which will be added later in this series.
2. It is desirable to be able to restrict those normal memory data sources. For instance, to ensure that the source data is executable before copying data to an executable enclave page.
3. Enclave page permissions are dynamic (just like normal permissions) and can be adjusted at runtime withmprotect().This creates a problem because the original data source may have long since vanished at the time when enclave page permissions are established (
mmap()ormprotect()).The solution (elsewhere in this series) is to force enclaves creators to declare their paging permission *intent* up front to the
ioctl(). This intent can be immediately compared to the source data???s mapping and rejected if necessary.The ???intent??? is also stashed off for later comparison with enclave PTEs. This ensures that any future mmap()/mprotect() operations performed by the enclave creator or done on behalf of the enclave can be compared with the earlier declared permissions.
Problem
=======There is an existing
mmap()hook which allows SGX to perform this permission comparison atmmap()time. However, there is no corresponding ->mprotect() hook.Solution
========Add a
vm_ops->mprotect()hook so thatmprotect()operations which are inconsistent with any page's stashed intent can be rejected by the driver.Cc Andrew Morton <[email protected]>Cc Matthew Wilcox <[email protected]>Cc Mel Gorman <[email protected]>Quoted 3 lines
# Signed-off-by: Sean Christopherson <[email protected]>
Co-developed-by Jarkko Sakkinen <[email protected]>Signed-off-by Jarkko Sakkinen <[email protected]>
Quoted 1 line
Acked-by Mel Gorman <[email protected]>
Thank you.
/Jarkko
Jarkko Sakkinen
maintainerRe: [PATCH v41 10/24] mm: Add 'mprotect' hook to struct vm_operations_struct
In reply to a message not in the archiveQuoted 53 lines · Hillf Danton
On Fri, 13 Nov 2020 00:01:21 +0200
Quoted 47 lines
From: Sean Christopherson <[email protected]>
Background
==========1. SGX enclave pages are populated with data by copying from normal memory via
ioctl()(SGX_IOC_ENCLAVE_ADD_PAGES), which will be added later in this series.
2. It is desirable to be able to restrict those normal memory data sources. For instance, to ensure that the source data is executable before copying data to an executable enclave page.
3. Enclave page permissions are dynamic (just like normal permissions) and can be adjusted at runtime withmprotect().This creates a problem because the original data source may have long since vanished at the time when enclave page permissions are established (
mmap()ormprotect()).The solution (elsewhere in this series) is to force enclaves creators to declare their paging permission *intent* up front to the
ioctl(). This intent can be immediately compared to the source data’s mapping and rejected if necessary.The “intent” is also stashed off for later comparison with enclave PTEs. This ensures that any future mmap()/mprotect() operations performed by the enclave creator or done on behalf of the enclave can be compared with the earlier declared permissions.
Problem
=======There is an existing
mmap()hook which allows SGX to perform this permission comparison atmmap()time. However, there is no corresponding ->mprotect() hook.Solution
========Add a
vm_ops->mprotect()hook so thatmprotect()operations which are inconsistent with any page's stashed intent can be rejected by the driver.Cc Andrew Morton <[email protected]>Cc Matthew Wilcox <[email protected]>Cc Mel Gorman <[email protected]>Quoted 4 lines
# Signed-off-by: Sean Christopherson <[email protected]>
Co-developed-by Jarkko Sakkinen <[email protected]>Signed-off-by Jarkko Sakkinen <[email protected]>---
Quoted 1 line
Acked-by Hillf Danton <[email protected]>
Thank you.
/Jarkko
Jarkko Sakkinen
maintainerRe: [PATCH v41 10/24] mm: Add 'mprotect' hook to struct vm_operations_struct
In reply to Mel GormanQuoted 13 lines · Mel Gorman
Quoted 12 lines · Dave Hansen
Quoted 11 lines · Matthew Wilcox
include/linux/mm.h struct vm_operations_struct { · line 566
Quoted 10 lines · Jarkko Sakkinen
+++
b/include/linux/mm.hinclude/linux/mm.h +5
-0@@ -559,6 +559,13 @@ struct vm_operations_struct {void (*close)(struct vm_area_struct * area);int (*split)(struct vm_area_struct * area,unsigned long addr);int (*mremap)(struct vm_area_struct * area); +/* +* Called by mprotect() to make driver-specific permission +* checks before mprotect() is finalised. The VMA must not +* be modified. Returns 0 if eprotect() can proceed. +*/
Wonder if this should also document the negative case for the return value, i.e. -EACCES is returned otherwise.
Quoted 8 lines
Quoted 7 lines
Quoted 4 lines
This is the wrong place for this documentation, and it's absurdly specific to your implementation. It should be in
Documentation/filesystems/locking.rst.I'll let you and Mel duke that one out:
Quoted 10 lines
I suggested placing the comment there to make it clear what the expected semantics of the hook was to reduce the chances of abuse or surprises. The hook does not affect locking so
Documentation/filesystems/locking.rstdidn't appear appropriate other than maybe adding a note there that it doesn't affect locks. The hook also is not expecting any filesystems-specific action that I aware of but a note could be added to the effect that filesystems should not need to take special action for it. Protections on the filesystem level are for the inode, I can't imagine what a filesystem would do with a protection change on the page table level but maybe I'm not particularly imaginative today.
I try to decipher this in generic context.
In a permission check of a filesystem, truncated pages should be encapsulated in to the permission decision. It's a just a query.
So maybe I'll add something like:
"This callback does only a permission query, and thus does never return locked pages."
Quoted 3 lines
Signature · 2 lines
Mel Gorman SUSE Labs
/Jarkko
Jarkko Sakkinen
maintainerQuoted 7 lines · Borislav Petkov
Quoted 3 lines · Dave Hansen
That works when there is something universal across the set, like if Sean Signed-off-by on each patch and we didn't have any other SoB's. Sean is also mentioned in at least one of five different tags:
So?
Quoted 8 lines
You git-format-patch, build the CC-list and supply it with --cc-cmd or whatever scripting you have and do --suppress-cc=all as the last switch.
Quoted 1 line
The bounces aren't the end of the world, they're just annoying.
And I have to go edit every patch by hand to remove those comments again. No, bounces happen all the time and we ignore them simply. Can't fix them all.
I'm fine with either way.
Quoted 5 lines
Signature · 4 lines
Regards/Gruss, Boris. https://people.kernel.org/tglx/notes-about-netiquette
/Jarkko
Jarkko Sakkinen
maintainerRe: [PATCH] x86/sgx: clarify 'laundry_list' locking
In reply to Dave HansenQuoted 44 lines · Dave Hansen
From: Dave Hansen <[email protected]>
Short Version:
The SGX
section->laundry_liststructure is effectively thread-local, but declared next to some shared structures. Its semantics are clear as mud. Fix that. No functional changes. Compile tested only.Long Version:
The SGX hardware keeps per-page metadata. This can provide things like permissions, integrity and replay protection. It also prevents things like having an enclave page mapped multiple times or shared between enclaves.
But, that presents a problem for kexec()'d kernels (or any other kernel that does not run immediately after a hardware reset). This is because the last kernel may have been rude and forgotten to reset pages, which would trigger the the "shared page" sanity check.
To fix this, the SGX code "launders" the pages by running the EREMOVE instruction on all pages at boot. This is slow and can take a long time, so it is performed off in the SGX-specific ksgxd instead of being synchronous at boot. The init code hands the list of pages to launder in a per-SGX-section list: ->laundry_list. The only code to touch this list is the init code and ksgxd. This means that no locking is necessary for ->laundry_list.
However, a lock is required for
section->page_list, which is accessed while creating enclaves and by ksgxd. This lock (section->lockis acquired by ksgxd while also processing ->laundry_list. It is easy to confuse the purpose of the locking as being for ->laundry_list and ->page_list.Rename ->laundry_list to ->init_laundry_list to make it clear that this is not normally used at runtime. Also add some comments clarifying the locking, and reorganize '
sgx_epc_section' to put 'lock' near the things it protects.Note:
init_laundry_listis 128 bytes of wasted space at runtime. It could theoretically be dynamically allocated and then freed after the laundering process. But, I suspect it would take nearly 128 bytes of extra instructions to do that.
Quoted 5 lines
Cc Jethro Beekman <[email protected]>Cc Serge Ayoun <[email protected]>Cc Jarkko Sakkinen <[email protected]>Signed-off-by Jarkko Sakkinen <[email protected]>Signed-off-by Dave Hansen <[email protected]>
Thansk, this does make sense to me. I'll squash it.
/Jarkko
Quoted 94 lines
---
b/arch/x86/kernel/cpu/sgx/main.c | 14 ++++++++------ b/arch/x86/kernel/cpu/sgx/sgx.h | 15 ++++++++++++--- 2 files changed, 20 insertions(+), 9 deletions(-)diff -puN
arch/x86/kernel/cpu/sgx/main.c~sgx-laundry-commentsarch/x86/kernel/cpu/sgx/main.carch/x86/kernel/cpu/sgx/main.c renamed from arch/x86/kernel/cpu/sgx/main.c~sgx-laundry-comments +8
-6@@ -36,13 +36,15 @@ static void sgx_sanitize_section(structLIST_HEAD (dirty);int ret; -while (!list_empty (§ion->laundry_list)) { +/* init_laundry_list is thread-local, no need for a lock: */ +while (!list_empty (§ion->init_laundry_list)) {if (kthread_should_stop ())return ; +/* needed for access to ->page_list: */ spin_lock (§ion->lock); - page =list_first_entry (§ion->laundry_list, + page =list_first_entry (§ion->init_laundry_list, struct sgx_epc_page, list); ret =__eremove (sgx_get_epc_virt_addr (page));@@ -56,7 +58,7 @@ static void sgx_sanitize_section(structcond_resched (); } -list_splice (&dirty, §ion->laundry_list); +list_splice (&dirty, §ion->init_laundry_list); }static bool sgx_reclaimer_age (struct sgx_epc_page *epc_page)@@ -418,7 +420,7 @@ static int ksgxswapd(void *p)sgx_sanitize_section (&sgx_epc_sections[i]);/* Should never happen. */ -if (!list_empty (&sgx_epc_sections[i].laundry_list)) +if (!list_empty (&sgx_epc_sections[i].init_laundry_list))WARN (1 ,"EPC section %d has unsanitized pages.\n" , i); }@@ -632,13 +634,13 @@ static bool __init sgx_setup_epc_section section->phys_addr = phys_addr;spin_lock_init (§ion->lock);INIT_LIST_HEAD (§ion->page_list); -INIT_LIST_HEAD (§ion->laundry_list); +INIT_LIST_HEAD (§ion->init_laundry_list);for (i =0 ; i < nr_pages; i++) { section->pages[i].section = index; section->pages[i].flags =0 ; section->pages[i].owner =NULL ; -list_add_tail (§ion->pages[i].list, §ion->laundry_list); +list_add_tail (§ion->pages[i].list, §ion->init_laundry_list); } section->free_cnt = nr_pages;diff -puN
arch/x86/kernel/cpu/sgx/sgx.h~sgx-laundry-commentsarch/x86/kernel/cpu/sgx/sgx.harch/x86/kernel/cpu/sgx/sgx.h renamed from arch/x86/kernel/cpu/sgx/sgx.h~sgx-laundry-comments +12
-3@@ -34,15 +34,24 @@ struct sgx_epc_page {* 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. +* +* 'lock' must be held before accessing 'page_list' or 'free_cnt'. */ 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; -unsigned long free_cnt; +spinlock_t lock; +struct list_head page_list; +unsigned long free_cnt; + +/* +* Pages which need EREMOVE run on them before they can be +* used. Only safe to be accessed in ksgxd and init code. +* Not protected by locks. +*/ +struct list_head init_laundry_list; };extern struct sgx_epc_section sgx_epc_sections[SGX_MAX_EPC_SECTIONS ];_
Jarkko Sakkinen
maintainerRe: [PATCH v41 19/24] x86/vdso: Implement a vDSO for Intel SGX enclave call
In reply to Borislav PetkovQuoted 13 lines · Borislav Petkov
arch/x86/entry/vdso/Makefile VDSO32-$(CONFIG_IA32_EMULATION) := y · line 30
Quoted 9 lines · Jarkko Sakkinen
arch/x86/entry/vdso/Makefile +1
-0@@ -27,6 +27,7 @@ VDSO32-$(CONFIG_IA32_EMULATION) := y vobjs-y := vdso-note.o vclock_gettime.o vgetcpu.o vobjs32-y := vdso32/note.o vdso32/system_call.o vdso32/sigreturn.o vobjs32-y += vdso32/vclock_gettime.o +vobjs-$(VDSO64-y) += vsgx.oWhy?
Quoted 2 lines
This needs to be
CONFIG_X86_SGXas you need this vdso functionality only when SGX is enabled.
Agreed.
Quoted 5 lines
Signature · 4 lines
Regards/Gruss, Boris. https://people.kernel.org/tglx/notes-about-netiquette
/Jarkko
Jarkko Sakkinen
maintainerRe: [PATCH v41 20/24] selftests/x86: Add a selftest for SGX
In reply to Shuah KhanQuoted 97 lines · Shuah Khan
Quoted 46 lines · Jarkko Sakkinen
Add a selftest for SGX. It is a trivial test where a simple enclave copies one 64-bit word of memory between two memory locations, but ensures that all SGX hardware and software infrastructure is functioning.
Cc Shuah Khan <[email protected]>Signed-off-by Jarkko Sakkinen <[email protected]>---
Changes from v40:
* Remove $(OUTPUT)/test_encl.elf fromTEST_CUSTOM_PROGS, as otherwiserun_teststries to execute it. Add it as a build dependency.
* Use the correct device path,/dev/sgx_enclave, instead of/dev/sgx/enclave.
* Return kselftest framework expected return codes.tools/testing/selftests/Makefile | 1 + tools/testing/selftests/sgx/.gitignore | 2 + tools/testing/selftests/sgx/Makefile | 53 +++ tools/testing/selftests/sgx/call.S | 44 ++ tools/testing/selftests/sgx/defines.h | 21 + tools/testing/selftests/sgx/load.c | 277 +++++++++++++ tools/testing/selftests/sgx/main.c | 246 +++++++++++ tools/testing/selftests/sgx/main.h | 38 ++ tools/testing/selftests/sgx/sigstruct.c | 391 ++++++++++++++++++ tools/testing/selftests/sgx/test_encl.c | 20 + tools/testing/selftests/sgx/test_encl.lds | 40 ++ .../selftests/sgx/test_encl_bootstrap.S | 89 ++++ 12 files changed, 1222 insertions(+)create mode 100644
tools/testing/selftests/sgx/.gitignorecreate mode 100644tools/testing/selftests/sgx/Makefilecreate mode 100644tools/testing/selftests/sgx/call.Screate mode 100644tools/testing/selftests/sgx/defines.hcreate mode 100644tools/testing/selftests/sgx/load.ccreate mode 100644tools/testing/selftests/sgx/main.ccreate mode 100644tools/testing/selftests/sgx/main.hcreate mode 100644tools/testing/selftests/sgx/sigstruct.ccreate mode 100644tools/testing/selftests/sgx/test_encl.ccreate mode 100644tools/testing/selftests/sgx/test_encl.ldscreate mode 100644tools/testing/selftests/sgx/test_encl_bootstrap.Stools/testing/selftests/Makefile +0
-0tools/testing/selftests/Makefile TARGETS += user · line 72
Quoted 5 lines
tools/testing/selftests/Makefile +1
-0@@ -68,6 +68,7 @@ TARGETS += user TARGETS += vm TARGETS += x86 TARGETS += zram +TARGETS += sgx #Please keep the TARGETS list alphabetically sortedPlease keep the list sorted alphabetically as stated in the comment above.
Quoted 27 lines
tools/testing/selftests/Makefile +27
-0+} + +int main(int argc, char *argv[], char *envp[]) +{ + struct sgx_enclave_run run; + struct vdso_symtab symtab; + Elf64_Sym *eenter_sym; + uint64_t result = 0; + struct encl encl; + unsigned int i; + void *addr; + int ret; + + memset(&run, 0, sizeof(run)); + + if (!encl_load("test_encl.elf", &encl)) { + encl_delete(&encl); + ksft_exit_skip("cannot load enclaves\n"); + } + + if (!encl_measure(&encl)) + goto err; + + if (!encl_build(&encl)) + goto err; + + /*tools/testing/selftests/Makefile TARGETS += user
Quoted 10 lines
tools/testing/selftests/Makefile +10
-0+ * An enclave consumer only must do this. + */ + for (i = 0; i < encl.nr_segments; i++) { + struct encl_segment *seg = &encl.segment_tbl[i]; + + addr = mmap((void *)encl.encl_base + seg->offset, seg->size, + seg->prot, MAP_SHARED | MAP_FIXED, encl.fd, 0); + if (addr == MAP_FAILED) { + fprintf(stderr, "mmap() failed, errno=%d.\n", errno); + exit(1);This should be
KSFT_FAIL.
Quoted 2 lines
thanks,
-- Shuah
Thanks.
/Jarkko
Jarkko Sakkinen
maintainerRe: [PATCH v41 20/24] selftests/x86: Add a selftest for SGX
In reply to Borislav PetkovQuoted 107 lines · Borislav Petkov
Quoted 79 lines · Jarkko Sakkinen
tools/testing/selftests/sgx/load.c new file +79
-0+bool encl_load (const char *path,struct encl *encl) +{ +Elf64_Phdr *phdr_tbl; +off_t src_offset; +Elf64_Ehdr *ehdr; +int i, j; +int ret; + +memset (encl,0 ,sizeof (*encl)); + + ret =open ("/dev/sgx_enclave" ,O_RDWR ); +if (ret <0 ) { +fprintf (stderr,"Unable to open /dev/sgx_enclave\n" ); + goto err; + } + + encl->fd = ret; + +if (!encl_map_bin (path, encl)) + goto err; + + ehdr = encl->bin; + phdr_tbl = encl->bin + ehdr->e_phoff; + +for (i =0 ; i < ehdr->e_phnum; i++) { +Elf64_Phdr *phdr = &phdr_tbl[i]; + +if (phdr->p_type ==PT_LOAD ) + encl->nr_segments++; + } + + encl->segment_tbl =calloc (encl->nr_segments, +sizeof (struct encl_segment )); +if (!encl->segment_tbl) + goto err; + +for (i =0 , j =0 ; i < ehdr->e_phnum; i++) { +Elf64_Phdr *phdr = &phdr_tbl[i]; +unsigned int flags = phdr->p_flags; +struct encl_segment *seg; + +if (phdr->p_type !=PT_LOAD ) +continue ; + + seg = &encl->segment_tbl[j]; + +if (!!(flags & ~(PF_R |PF_W |PF_X ))) { +fprintf (stderr, +"%d has invalid segment flags 0x%02x.\n" , i, + phdr->p_flags); + goto err; + } + +if (j ==0 && flags != (PF_R |PF_W )) { +fprintf (stderr, +"TCS has invalid segment flags 0x%02x.\n" , + phdr->p_flags); + goto err; + } + +if (j ==0 ) { + src_offset = (phdr->p_offset &PAGE_MASK ) - src_offset; + + seg->prot =PROT_READ |PROT_WRITE ; + seg->flags =SGX_PAGE_TYPE_TCS <<8 ; + }else { + seg->prot = (phdr->p_flags &PF_R ) ?PROT_READ :0 ; + seg->prot |= (phdr->p_flags &PF_W ) ?PROT_WRITE :0 ; + seg->prot |= (phdr->p_flags &PF_X ) ?PROT_EXEC :0 ; + seg->flags = (SGX_PAGE_TYPE_REG <<8 ) | seg->prot; + } + + seg->offset = (phdr->p_offset &PAGE_MASK ) - src_offset; + seg->size = (phdr->p_filesz +PAGE_SIZE -1 ) &PAGE_MASK ; + +printf ("0x%016lx 0x%016lx 0x%02x\n" , seg->offset, seg->size, + seg->prot); + + j++;tools/testing/selftests/sgx/load.c line 215
Quoted 10 lines
tools/testing/selftests/sgx/load.c new file +10
-0+ } + +assert (j == encl->nr_segments); + + encl->src = encl->bin + src_offset; + encl->src_size = encl->segment_tbl[j -1 ].offset + + encl->segment_tbl[j -1 ].size; + +for (encl->encl_size =4096 ; encl->encl_size < encl->src_size; ) + encl->encl_size <<=1 ;Something's fishy. That selftest fails with
mmap: Cannot allocate memory
I sprinkled some printfs at this size computation above and here's what it says:
0x00007fdd3b4ca1900x00000000000020000x030x00007fdd3b4cc1900x00000000000010000x050x00007fdd3b4cd1900x00000000000030000x03encl_load:encl->nr_segments: 3encl_load: seg2 offset:0x7fdd3b4cd190, seg2 size: 12288encl_load:encl_size: 140737488355328,src_size: 140588159402384encl_map_area:encl_size: 140737488355328
mmap: Cannot allocate memory
Quoted 2 lines
src_sizeis computed by adding the offset and size of the last segment which is at index 2.
src_size does not look right. I'll debug.
Quoted 2 lines
The loop computes
encl_sizeto0x0000800000000000then and mmap tries to map double that inencl_map_area(). Looks like too much to me too.
The enclave base must be naturally aligned in relative to its size.
Quoted 7 lines
What's up?
Signature · 4 lines
Regards/Gruss, Boris. https://people.kernel.org/tglx/notes-about-netiquette
/Jarkko
Jarkko Sakkinen
maintainerRe: [PATCH v41 20/24] selftests/x86: Add a selftest for SGX
In reply to Borislav PetkovQuoted 98 lines · Borislav Petkov
Quoted 79 lines · Jarkko Sakkinen
(quoted diff) +79
-0+bool encl_load(const char *path, struct encl *encl) +{ + Elf64_Phdr *phdr_tbl; + off_t src_offset; + Elf64_Ehdr *ehdr; + int i, j; + int ret; + + memset(encl, 0, sizeof(*encl)); + + ret = open("/dev/sgx_enclave", O_RDWR); + if (ret < 0) { + fprintf(stderr, "Unable to open /dev/sgx_enclave\n"); + goto err; + } + + encl->fd = ret; + + if (!encl_map_bin(path, encl)) + goto err; + + ehdr = encl->bin; + phdr_tbl = encl->bin + ehdr->e_phoff; + + for (i = 0; i < ehdr->e_phnum; i++) { + Elf64_Phdr *phdr = &phdr_tbl[i]; + + if (phdr->p_type == PT_LOAD) + encl->nr_segments++; + } + + encl->segment_tbl = calloc(encl->nr_segments, + sizeof(struct encl_segment)); + if (!encl->segment_tbl) + goto err; + + for (i = 0, j = 0; i < ehdr->e_phnum; i++) { + Elf64_Phdr *phdr = &phdr_tbl[i]; + unsigned int flags = phdr->p_flags; + struct encl_segment *seg; + + if (phdr->p_type != PT_LOAD) + continue; + + seg = &encl->segment_tbl[j]; + + if (!!(flags & ~(PF_R | PF_W | PF_X))) { + fprintf(stderr, + "%d has invalid segment flags 0x%02x.\n", i, + phdr->p_flags); + goto err; + } + + if (j == 0 && flags != (PF_R | PF_W)) { + fprintf(stderr, + "TCS has invalid segment flags 0x%02x.\n", + phdr->p_flags); + goto err; + } + + if (j == 0) { + src_offset = (phdr->p_offset & PAGE_MASK) - src_offset; + + seg->prot = PROT_READ | PROT_WRITE; + seg->flags = SGX_PAGE_TYPE_TCS << 8; + } else { + seg->prot = (phdr->p_flags & PF_R) ? PROT_READ : 0; + seg->prot |= (phdr->p_flags & PF_W) ? PROT_WRITE : 0; + seg->prot |= (phdr->p_flags & PF_X) ? PROT_EXEC : 0; + seg->flags = (SGX_PAGE_TYPE_REG << 8) | seg->prot; + } + + seg->offset = (phdr->p_offset & PAGE_MASK) - src_offset; + seg->size = (phdr->p_filesz + PAGE_SIZE - 1) & PAGE_MASK; + + printf("0x%016lx 0x%016lx 0x%02x\n", seg->offset, seg->size, + seg->prot); + + j++;Review
Quoted 10 lines
(quoted diff) +10
-0+ } + + assert(j == encl->nr_segments); + + encl->src = encl->bin + src_offset; + encl->src_size = encl->segment_tbl[j - 1].offset + + encl->segment_tbl[j - 1].size; + + for (encl->encl_size = 4096; encl->encl_size < encl->src_size; ) + encl->encl_size <<= 1;Something's fishy. That selftest fails with
mmap: Cannot allocate memory
I sprinkled some printfs at this size computation above and here's what it says:
Quoted 8 lines
0x00007fdd3b4ca1900x00000000000020000x030x00007fdd3b4cc1900x00000000000010000x050x00007fdd3b4cd1900x00000000000030000x03encl_load:encl->nr_segments: 3encl_load: seg2 offset:0x7fdd3b4cd190, seg2 size: 12288encl_load:encl_size: 140737488355328,src_size: 140588159402384encl_map_area:encl_size: 140737488355328
mmap: Cannot allocate memory
In my machine, with the current version:
➜ sgx (master) ✗ ./test_sgx0x0000000000000000 0x0000000000002000 0x030x0000000000002000 0x0000000000001000 0x050x0000000000003000 0x0000000000003000 0x03
SUCCESS
This the bug, src_offset initialization:
tools/testing/selftests/sgx/load.c +1 -1
@@ -185,7 +185,7 @@ bool encl_load(const char *path, struct encl *encl) }if (j ==0 ) { - src_offset = (phdr->p_offset &PAGE_MASK ) - src_offset; + src_offset = phdr->p_offset &PAGE_MASK ; seg->prot =PROT_READ |PROT_WRITE ; seg->flags =SGX_PAGE_TYPE_TCS <<8 ;
This was introduced when moving from converting elf to bin to load directly from elf. In my case 'src_offset' happened to be zero and I have not thus noticed this before.
/Jarkko
[tip: x86/sgx] mm: Add 'mprotect' hook to struct vm_operations_struct
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 95bb7c42ac8a94ce3d0eb059ad64430390351ccb Gitweb: https://git.kernel.org/tip/95bb7c42ac8a94ce3d0eb059ad64430390351ccb Author: Sean Christopherson <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:21 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Tue, 17 Nov 2020 14:36:14 +01:00
mm: Add 'mprotect' hook to struct vm_operations_struct
Background
==========
1. SGX enclave pages are populated with data by copying from normal memory via ioctl() (SGX_IOC_ENCLAVE_ADD_PAGES), which will be added later in this series.
2. It is desirable to be able to restrict those normal memory data sources. For instance, to ensure that the source data is executable before copying data to an executable enclave page.
3. Enclave page permissions are dynamic (just like normal permissions) and can be adjusted at runtime with mprotect().
This creates a problem because the original data source may have long since vanished at the time when enclave page permissions are established (mmap() or mprotect()).
The solution (elsewhere in this series) is to force enclave creators to declare their paging permission *intent* up front to the ioctl(). This intent can be immediately compared to the source data’s mapping and rejected if necessary.
The “intent” is also stashed off for later comparison with enclave PTEs. This ensures that any future mmap()/mprotect() operations performed by the enclave creator or done on behalf of the enclave can be compared with the earlier declared permissions.
Problem
=======
There is an existing mmap() hook which allows SGX to perform this permission comparison at mmap() time. However, there is no corresponding ->mprotect() hook.
Solution
========
Add a vm_ops->mprotect() hook so that mprotect() operations which are inconsistent with any page's stashed intent can be rejected by the driver.
--- include/linux/mm.h | 7 +++++++ mm/mprotect.c | 7 +++++++ 2 files changed, 14 insertions(+)
include/linux/mm.h +7 -0
@@ -559,6 +559,13 @@ struct vm_operations_struct {void (*close)(struct vm_area_struct * area);int (*split)(struct vm_area_struct * area,unsigned long addr);int (*mremap)(struct vm_area_struct * area); +/* +* Called by mprotect() to make driver-specific permission +* checks before mprotect() is finalised. The VMA must not +* be modified. Returns 0 if eprotect() can proceed. +*/ +int (*mprotect)(struct vm_area_struct *vma,unsigned long start, +unsigned long end,unsigned long newflags);vm_fault_t (*fault)(struct vm_fault *vmf);vm_fault_t (*huge_fault)(struct vm_fault *vmf,enum page_entry_size pe_size);
mm/mprotect.c +7 -0
@@ -616,9 +616,16 @@ static int do_mprotect_pkey(unsigned long start, size_t len, tmp = vma->vm_end;if (tmp > end) tmp = end; + +if (vma->vm_ops && vma->vm_ops->mprotect) + error = vma->vm_ops->mprotect (vma, nstart, tmp, newflags); +if (error) + goto out; + error =mprotect_fixup (vma, &prev, nstart, tmp, newflags);if (error) goto out; + nstart = tmp;if (nstart < prev->vm_end)
[tip: x86/sgx] x86/sgx: Clarify 'laundry_list' locking
In reply to Dave HansenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 67655b57f8f59467506463055d9a8398d2836377 Gitweb: https://git.kernel.org/tip/67655b57f8f59467506463055d9a8398d2836377 Author: Dave Hansen <[email protected]> AuthorDate: Mon, 16 Nov 2020 14:25:31 -08:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Wed, 18 Nov 2020 18:16:28 +01:00
x86/sgx: Clarify 'laundry_list' locking
Short Version:
The SGX section->laundry_list structure is effectively thread-local, but declared next to some shared structures. Its semantics are clear as mud. Fix that. No functional changes. Compile tested only.
Long Version:
The SGX hardware keeps per-page metadata. This can provide things like permissions, integrity and replay protection. It also prevents things like having an enclave page mapped multiple times or shared between enclaves.
But, that presents a problem for kexec()'d kernels (or any other kernel that does not run immediately after a hardware reset). This is because the last kernel may have been rude and forgotten to reset pages, which would trigger the "shared page" sanity check.
To fix this, the SGX code "launders" the pages by running the EREMOVE instruction on all pages at boot. This is slow and can take a long time, so it is performed off in the SGX-specific ksgxd instead of being synchronous at boot. The init code hands the list of pages to launder in a per-SGX-section list: ->laundry_list. The only code to touch this list is the init code and ksgxd. This means that no locking is necessary for ->laundry_list.
However, a lock is required for section->page_list, which is accessed while creating enclaves and by ksgxd. This lock (section->lock) is acquired by ksgxd while also processing ->laundry_list. It is easy to confuse the purpose of the locking as being for ->laundry_list and ->page_list.
Rename ->laundry_list to ->init_laundry_list to make it clear that this is not normally used at runtime. Also add some comments clarifying the locking, and reorganize 'sgx_epc_section' to put 'lock' near the things it protects.
Note: init_laundry_list is 128 bytes of wasted space at runtime. It could theoretically be dynamically allocated and then freed after the laundering process. But it would take nearly 128 bytes of extra instructions to do that.
--- arch/x86/kernel/cpu/sgx/main.c | 14 ++++++++------ arch/x86/kernel/cpu/sgx/sgx.h | 15 ++++++++++++--- 2 files changed, 20 insertions(+), 9 deletions(-)
arch/x86/kernel/cpu/sgx/main.c +8 -6
@@ -36,13 +36,15 @@ static void sgx_sanitize_section(struct sgx_epc_section *section)LIST_HEAD (dirty);int ret; -while (!list_empty (§ion->laundry_list)) { +/* init_laundry_list is thread-local, no need for a lock: */ +while (!list_empty (§ion->init_laundry_list)) {if (kthread_should_stop ())return ; +/* needed for access to ->page_list: */ spin_lock (§ion->lock); - page =list_first_entry (§ion->laundry_list, + page =list_first_entry (§ion->init_laundry_list, struct sgx_epc_page, list); ret =__eremove (sgx_get_epc_virt_addr (page));
@@ -56,7 +58,7 @@ static void sgx_sanitize_section(struct sgx_epc_section *section)cond_resched (); } -list_splice (&dirty, §ion->laundry_list); +list_splice (&dirty, §ion->init_laundry_list); }static bool sgx_reclaimer_age (struct sgx_epc_page *epc_page)
@@ -418,7 +420,7 @@ static int ksgxd(void *p)sgx_sanitize_section (&sgx_epc_sections[i]);/* Should never happen. */ -if (!list_empty (&sgx_epc_sections[i].laundry_list)) +if (!list_empty (&sgx_epc_sections[i].init_laundry_list))WARN (1 ,"EPC section %d has unsanitized pages.\n" , i); }
@@ -635,13 +637,13 @@ static bool __init sgx_setup_epc_section(u64 phys_addr, u64 size, section->phys_addr = phys_addr;spin_lock_init (§ion->lock);INIT_LIST_HEAD (§ion->page_list); -INIT_LIST_HEAD (§ion->laundry_list); +INIT_LIST_HEAD (§ion->init_laundry_list);for (i =0 ; i < nr_pages; i++) { section->pages[i].section = index; section->pages[i].flags =0 ; section->pages[i].owner =NULL ; -list_add_tail (§ion->pages[i].list, §ion->laundry_list); +list_add_tail (§ion->pages[i].list, §ion->init_laundry_list); } section->free_cnt = nr_pages;
arch/x86/kernel/cpu/sgx/sgx.h +12 -3
@@ -34,15 +34,24 @@ struct sgx_epc_page {* 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. +* +* 'lock' must be held before accessing 'page_list' or 'free_cnt'. */ 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; -unsigned long free_cnt; +spinlock_t lock; +struct list_head page_list; +unsigned long free_cnt; + +/* +* Pages which need EREMOVE run on them before they can be +* used. Only safe to be accessed in ksgxd and init code. +* Not protected by locks. +*/ +struct list_head init_laundry_list; };extern struct sgx_epc_section sgx_epc_sections[SGX_MAX_EPC_SECTIONS ];
[tip: x86/sgx] x86/sgx: Update MAINTAINERS
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: bc4bac2ecef0e47fd5c02f9c6f9585fd477f9beb Gitweb: https://git.kernel.org/tip/bc4bac2ecef0e47fd5c02f9c6f9585fd477f9beb Author: Jarkko Sakkinen <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:35 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Wed, 18 Nov 2020 18:16:28 +01:00
x86/sgx: Update MAINTAINERS
Add the maintainer information for the SGX subsystem.
--- MAINTAINERS | 13 +++++++++++++ 1 file changed, 13 insertions(+)
MAINTAINERS +13 -0
@@ -9126,6 +9126,19 @@ F: Documentation/x86/intel_txt.rst F: arch/x86/kernel/tboot.c F: include/linux/tboot.h +INTEL SGX +M: Jarkko Sakkinen <[email protected]> +L: [email protected] +S: Supported +Q: https://patchwork.kernel.org/project/intel-sgx/list/ +T: git git://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-sgx.git +F: Documentation/x86/sgx.rst +F: arch/x86/entry/vdso/vsgx.S +F: arch/x86/include/uapi/asm/sgx.h +F: arch/x86/kernel/cpu/sgx/* +F: tools/testing/selftests/sgx/* +K: \bSGX_ + INTERCONNECT API M: Georgi Djakov <[email protected]> L: [email protected]
[tip: x86/sgx] x86/cpu/intel: Add a nosgx kernel parameter
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 38853a303982e3be3eccb1a1132399a5c5e2d806 Gitweb: https://git.kernel.org/tip/38853a303982e3be3eccb1a1132399a5c5e2d806 Author: Jarkko Sakkinen <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:19 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Tue, 17 Nov 2020 14:36:13 +01:00
x86/cpu/intel: Add a nosgx kernel parameter
Add a kernel parameter to disable SGX kernel support and document it.
[ bp: Massage. ]
--- Documentation/admin-guide/kernel-parameters.txt | 2 ++ arch/x86/kernel/cpu/feat_ctl.c | 9 +++++++++ 2 files changed, 11 insertions(+)
Documentation/admin-guide/kernel-parameters.txt +2 -0
@@ -3368,6 +3368,8 @@ nosep [BUGS=X86-32] Disables x86 SYSENTER/SYSEXIT support. + nosgx [X86-64,SGX] Disables Intel SGX kernel support. + nosmp [SMP] Tells an SMP kernel to act as a UP kernel, and disable the IO APIC. legacy for "maxcpus=0".
arch/x86/kernel/cpu/feat_ctl.c +9 -0
@@ -99,6 +99,15 @@ static void clear_sgx_caps(void)setup_clear_cpu_cap (X86_FEATURE_SGX_LC ); } +static int __init nosgx (char *str) +{ +clear_sgx_caps (); + +return 0 ; +} + +early_param ("nosgx" , nosgx); +void init_ia32_feat_ctl (struct cpuinfo_x86 *c) {bool tboot =tboot_enabled ();
[tip: x86/sgx] selftests/x86: Add a selftest for SGX
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 2adcba79e69d4a4c0ac3bb86f466d8b5df301608 Gitweb: https://git.kernel.org/tip/2adcba79e69d4a4c0ac3bb86f466d8b5df301608 Author: Jarkko Sakkinen <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:31 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Wed, 18 Nov 2020 18:04:05 +01:00
selftests/x86: Add a selftest for SGX
Add a selftest for SGX. It is a trivial test where a simple enclave copies one 64-bit word of memory between two memory locations, but ensures that all SGX hardware and software infrastructure is functioning.
--- tools/testing/selftests/Makefile | 1 +- tools/testing/selftests/sgx/.gitignore | 2 +- tools/testing/selftests/sgx/Makefile | 53 ++- tools/testing/selftests/sgx/call.S | 44 +- tools/testing/selftests/sgx/defines.h | 21 +- tools/testing/selftests/sgx/load.c | 277 +++++++++- tools/testing/selftests/sgx/main.c | 246 ++++++++- tools/testing/selftests/sgx/main.h | 38 +- tools/testing/selftests/sgx/sigstruct.c | 391 +++++++++++++- tools/testing/selftests/sgx/test_encl.c | 20 +- tools/testing/selftests/sgx/test_encl.lds | 40 +- tools/testing/selftests/sgx/test_encl_bootstrap.S | 89 +++- 12 files changed, 1222 insertions(+) create mode 100644 tools/testing/selftests/sgx/.gitignore create mode 100644 tools/testing/selftests/sgx/Makefile create mode 100644 tools/testing/selftests/sgx/call.S create mode 100644 tools/testing/selftests/sgx/defines.h create mode 100644 tools/testing/selftests/sgx/load.c create mode 100644 tools/testing/selftests/sgx/main.c create mode 100644 tools/testing/selftests/sgx/main.h create mode 100644 tools/testing/selftests/sgx/sigstruct.c create mode 100644 tools/testing/selftests/sgx/test_encl.c create mode 100644 tools/testing/selftests/sgx/test_encl.lds create mode 100644 tools/testing/selftests/sgx/test_encl_bootstrap.S
tools/testing/selftests/Makefile +1 -0
@@ -50,6 +50,7 @@ TARGETS += openat2 TARGETS += rseq TARGETS += rtc TARGETS += seccomp +TARGETS += sgx TARGETS += sigaltstack TARGETS += size TARGETS += sparc64
tools/testing/selftests/sgx/.gitignore new file +2 -0
@@ -0,0 +1,2 @@ +test_sgx +test_encl.elf
tools/testing/selftests/sgx/Makefile new file +53 -0
53 lines not on this page · raw message
tools/testing/selftests/sgx/call.S new file +44 -0
44 lines not on this page · raw message
tools/testing/selftests/sgx/defines.h new file +21 -0
@@ -0,0 +1,21 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright(c) 2016-20 Intel Corporation. +*/ + +#ifndef DEFINES_H +#define DEFINES_H + +#include <stdint.h> + +#define PAGE_SIZE 4096 +#define PAGE_MASK (~(PAGE_SIZE - 1)) + +#define __aligned (x) __attribute__((__aligned__(x))) +#define __packed __attribute__((packed)) + +#include "../../../../arch/x86/kernel/cpu/sgx/arch.h" +#include "../../../../arch/x86/include/asm/enclu.h" +#include "../../../../arch/x86/include/uapi/asm/sgx.h" + +#endif /* DEFINES_H */
tools/testing/selftests/sgx/load.c new file +277 -0
277 lines not on this page · raw message
tools/testing/selftests/sgx/main.c new file +246 -0
246 lines not on this page · raw message
tools/testing/selftests/sgx/main.h new file +38 -0
@@ -0,0 +1,38 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright(c) 2016-20 Intel Corporation. +*/ + +#ifndef MAIN_H +#define MAIN_H + +struct encl_segment { +off_t offset; +size_t size; +unsigned int prot; +unsigned int flags; +}; + +struct encl { +int fd; +void *bin; +off_t bin_size; +void *src; +size_t src_size; +size_t encl_size; +off_t encl_base; +unsigned int nr_segments; +struct encl_segment *segment_tbl; +struct sgx_secs secs; +struct sgx_sigstruct sigstruct; +}; + +void encl_delete (struct encl *ctx); +bool encl_load (const char *path,struct encl *encl); +bool encl_measure (struct encl *encl); +bool encl_build (struct encl *encl); + +int sgx_call_vdso (void *rdi,void *rsi,long rdx,u32 function,void *r8,void *r9, +struct sgx_enclave_run *run); + +#endif /* MAIN_H */
tools/testing/selftests/sgx/sigstruct.c new file +391 -0
391 lines not on this page · raw message
tools/testing/selftests/sgx/test_encl.c new file +20 -0
@@ -0,0 +1,20 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright(c) 2016-20 Intel Corporation. */ + +#include <stddef.h> +#include "defines.h" + +static void *memcpy (void *dest,const void *src,size_t n) +{ +size_t i; + +for (i =0 ; i < n; i++) + ((char *)dest)[i] = ((char *)src)[i]; + +return dest; +} + +void encl_body (void *rdi,void *rsi) +{ +memcpy (rsi, rdi,8 ); +}
tools/testing/selftests/sgx/test_encl.lds new file +40 -0
@@ -0,0 +1,40 @@ +OUTPUT_FORMAT(elf64-x86-64) + +PHDRS +{ + tcs PT_LOAD; + text PT_LOAD; + data PT_LOAD; +} + +SECTIONS +{ + . = 0; + .tcs : { + *(.tcs*) + } : tcs + + . = ALIGN(4096); + .text : { + *(.text*) + *(.rodata*) + } : text + + . = ALIGN(4096); + .data : { + *(.data*) + } : data + + /DISCARD/ : { + *(.comment*) + *(.note*) + *(.debug*) + *(.eh_frame*) + } +} + +ASSERT(!DEFINED(.altinstructions), "ALTERNATIVES are not supported in enclaves") +ASSERT(!DEFINED(.altinstr_replacement), "ALTERNATIVES are not supported in enclaves") +ASSERT(!DEFINED(.discard.retpoline_safe), "RETPOLINE ALTERNATIVES are not supported in enclaves") +ASSERT(!DEFINED(.discard.nospec), "RETPOLINE ALTERNATIVES are not supported in enclaves") +ASSERT(!DEFINED(.got.plt), "Libcalls are not supported in enclaves")
tools/testing/selftests/sgx/test_encl_bootstrap.S new file +89 -0
89 lines not on this page · raw message
[tip: x86/sgx] x86/sgx: Add a page reclaimer
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 1728ab54b4be94aed89276eeb8e750a345659765 Gitweb: https://git.kernel.org/tip/1728ab54b4be94aed89276eeb8e750a345659765 Author: Jarkko Sakkinen <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:32 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Wed, 18 Nov 2020 18:04:11 +01:00
x86/sgx: Add a page reclaimer
Just like normal RAM, there is a limited amount of enclave memory available and overcommitting it is a very valuable tool to reduce resource use. Introduce a simple reclaim mechanism for enclave pages.
In contrast to normal page reclaim, the kernel cannot directly access enclave memory. To get around this, the SGX architecture provides a set of functions to help. Among other things, these functions copy enclave memory to and from normal memory, encrypting it and protecting its integrity in the process.
Implement a page reclaimer by using these functions. Picks victim pages in LRU fashion from all the enclaves running in the system. A new kernel thread (ksgxswapd) reclaims pages in the background based on watermarks, similar to normal kswapd.
All enclave pages can be reclaimed, architecturally. But, there are some limits to this, such as the special SECS metadata page which must be reclaimed last. The page version array (used to mitigate replaying old reclaimed pages) is also architecturally reclaimable, but not yet implemented. The end result is that the vast majority of enclave pages are currently reclaimable.
--- arch/x86/kernel/cpu/sgx/driver.c | 59 ++-- arch/x86/kernel/cpu/sgx/encl.c | 483 +++++++++++++++++++++++++++++- arch/x86/kernel/cpu/sgx/encl.h | 51 +++- arch/x86/kernel/cpu/sgx/ioctl.c | 89 +++++- arch/x86/kernel/cpu/sgx/main.c | 466 +++++++++++++++++++++++++++++- arch/x86/kernel/cpu/sgx/sgx.h | 13 +- 6 files changed, 1134 insertions(+), 27 deletions(-)
arch/x86/kernel/cpu/sgx/driver.c +40 -19
@@ -17,13 +17,24 @@ u32 sgx_misc_reserved_mask;static int sgx_open (struct inode *inode,struct file *file) {struct sgx_encl *encl; +int ret; encl =kzalloc (sizeof (*encl),GFP_KERNEL );if (!encl)return -ENOMEM ; +kref_init (&encl->refcount);xa_init (&encl->page_array);mutex_init (&encl->lock); +INIT_LIST_HEAD (&encl->va_pages); +INIT_LIST_HEAD (&encl->mm_list); +spin_lock_init (&encl->mm_lock); + + ret =init_srcu_struct (&encl->srcu); +if (ret) { +kfree (encl); +return ret; + } file->private_data = encl;
@@ -33,31 +44,37 @@ static int sgx_open(struct inode *inode, struct file *file)static int sgx_release (struct inode *inode,struct file *file) {struct sgx_encl *encl = file->private_data; -struct sgx_encl_page *entry; -unsigned long index; - -xa_for_each (&encl->page_array, index, entry) { -if (entry->epc_page) { -sgx_free_epc_page (entry->epc_page); - encl->secs_child_cnt--; - entry->epc_page =NULL ; +struct sgx_encl_mm *encl_mm; + +/* +* Drain the remaining mm_list entries. At this point the list contains +* entries for processes, which have closed the enclave file but have +* not exited yet. The processes, which have exited, are gone from the +* list by sgx_mmu_notifier_release(). +*/ +for ( ; ; ) { +spin_lock (&encl->mm_lock); + +if (list_empty (&encl->mm_list)) { + encl_mm =NULL ; + }else { + encl_mm =list_first_entry (&encl->mm_list, + struct sgx_encl_mm, list); +list_del_rcu (&encl_mm->list); } -kfree (entry); - } +spin_unlock (&encl->mm_lock); -xa_destroy (&encl->page_array); +/* The enclave is no longer mapped by any mm. */ +if (!encl_mm) +break ; -if (!encl->secs_child_cnt && encl->secs.epc_page) { -sgx_free_epc_page (encl->secs.epc_page); - encl->secs.epc_page =NULL ; +synchronize_srcu (&encl->srcu); +mmu_notifier_unregister (&encl_mm->mmu_notifier, encl_mm->mm); +kfree (encl_mm); } -/* Detect EPC page leaks. */ -WARN_ON_ONCE (encl->secs_child_cnt); -WARN_ON_ONCE (encl->secs.epc_page); - -kfree (encl); +kref_put (&encl->refcount, sgx_encl_release);return 0 ; }
@@ -70,6 +87,10 @@ static int sgx_mmap(struct file *file, struct vm_area_struct *vma)if (ret)return ret; + ret =sgx_encl_mm_add (encl, vma->vm_mm); +if (ret) +return ret; + vma->vm_ops = &sgx_vm_ops; vma->vm_flags |=VM_PFNMAP |VM_DONTEXPAND |VM_DONTDUMP |VM_IO ; vma->vm_private_data = encl;
arch/x86/kernel/cpu/sgx/encl.c +479 -4
528 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/encl.h +51 -0
78 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/ioctl.c +85 -4
148 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/main.c +466 -0
517 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/sgx.h +13 -0
@@ -15,9 +15,17 @@#define SGX_MAX_EPC_SECTIONS 8#define SGX_EEXTEND_BLOCK_SIZE 256 +#define SGX_NR_TO_SCAN 16 +#define SGX_NR_LOW_PAGES 32 +#define SGX_NR_HIGH_PAGES 64 + +/* Pages, which are being tracked by the page reclaimer. */ +#define SGX_EPC_PAGE_RECLAIMER_TRACKED BIT(0)struct sgx_epc_page {unsigned int section; +unsigned int flags; +struct sgx_encl_page *owner;struct list_head list; };
@@ -33,6 +41,7 @@ struct sgx_epc_section {struct list_head page_list;struct list_head laundry_list;struct sgx_epc_page *pages; +unsigned long free_cnt;spinlock_t lock; };
@@ -61,4 +70,8 @@ static inline void *sgx_get_epc_virt_addr(struct sgx_epc_page *page)struct sgx_epc_page *__sgx_alloc_epc_page (void );void sgx_free_epc_page (struct sgx_epc_page *page); +void sgx_mark_page_reclaimable (struct sgx_epc_page *page); +int sgx_unmark_page_reclaimable (struct sgx_epc_page *page); +struct sgx_epc_page *sgx_alloc_epc_page (void *owner,bool reclaim); +#endif /* _X86_SGX_H */
[tip: x86/sgx] x86/sgx: Add wrappers for ENCLS functions
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 2c273671d0dfcf89c9c8a319ed093406e3ff665c Gitweb: https://git.kernel.org/tip/2c273671d0dfcf89c9c8a319ed093406e3ff665c Author: Jarkko Sakkinen <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:13 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Tue, 17 Nov 2020 14:36:12 +01:00
x86/sgx: Add wrappers for ENCLS functions
ENCLS is the userspace instruction which wraps virtually all unprivileged SGX functionality for managing enclaves. It is essentially the ioctl() of instructions with each function implementing different SGX-related functionality.
Add macros to wrap the ENCLS functionality. There are two main groups, one for functions which do not return error codes and a “ret_” set for those that do.
ENCLS functions are documented in Intel SDM section 36.6.
--- arch/x86/kernel/cpu/sgx/encls.h | 231 +++++++++++++++++++++++++++++++- 1 file changed, 231 insertions(+) create mode 100644 arch/x86/kernel/cpu/sgx/encls.h
arch/x86/kernel/cpu/sgx/encls.h new file +231 -0
@@ -0,0 +1,231 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _X86_ENCLS_H +#define _X86_ENCLS_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 <asm/traps.h> +#include "sgx.h" + +enum sgx_encls_function { +ECREATE =0x00 , +EADD =0x01 , +EINIT =0x02 , +EREMOVE =0x03 , +EDGBRD =0x04 , +EDGBWR =0x05 , +EEXTEND =0x06 , +ELDU =0x08 , +EBLOCK =0x09 , +EPA =0x0A , +EWB =0x0B , +ETRACK =0x0C , +}; + +/** +* ENCLS_FAULT_FLAG - flag signifying an ENCLS return code is a trapnr +* +* ENCLS has its own (positive value) error codes and also generates +* ENCLS specific #GP and #PF faults. And the ENCLS values get munged +* with system error codes as everything percolates back up the stack. +* Unfortunately (for us), we need to precisely identify each unique +* error code, e.g. the action taken if EWB fails varies based on the +* type of fault and on the exact SGX error code, i.e. we can't simply +* convert all faults to -EFAULT. +* +* To make all three error types coexist, we set bit 30 to identify an +* ENCLS fault. Bit 31 (technically bits N:31) is used to differentiate +* between positive (faults and SGX error codes) and negative (system +* error codes) values. +*/ +#define ENCLS_FAULT_FLAG 0x40000000 + +/* Retrieve the encoded trapnr from the specified return code. */ +#define ENCLS_TRAPNR (r) ((r) & ~ENCLS_FAULT_FLAG) + +/* Issue a WARN() about an ENCLS function. */ +#define ENCLS_WARN (r, name) { \ + do { \ + int _r = (r); \ + WARN_ONCE(_r, "%s returned %d (0x%x)\n", (name), _r, _r); \ + } while (0); \ +} + +/** +* encls_failed() - Check if an ENCLS function failed +* @ret: the return value of an ENCLS function call +* +* Check if an ENCLS function failed. This happens when the function causes a +* fault that is not caused by an EPCM conflict or when the function returns a +* non-zero value. +*/ +static inline bool encls_failed (int ret) +{ +if (ret &ENCLS_FAULT_FLAG ) +return ENCLS_TRAPNR (ret) !=X86_TRAP_PF ; + +return !!ret; +} + +/** +* __encls_ret_N - encode an ENCLS function that returns an error code in EAX +* @rax: function number +* @inputs: asm inputs for the function +* +* Emit assembly for an ENCLS function that returns an error code, e.g. EREMOVE. +* And because SGX isn't complex enough as it is, function that return an error +* code also modify flags. +* +* Return: +* 0 on success, +* SGX error code on failure +*/ +#define __encls_ret_N(rax, inputs...) \ + ({ \ + int ret; \ + asm volatile( \ + "1: .byte 0x0f, 0x01, 0xcf;\n\t" \ + "2:\n" \ + ".section .fixup,\"ax\"\n" \ + "3: orl $"__stringify(ENCLS_FAULT_FLAG)",%%eax\n" \ + " jmp 2b\n" \ + ".previous\n" \ + _ASM_EXTABLE_FAULT(1b, 3b) \ + : "=a"(ret) \ + : "a"(rax), inputs \ + : "memory", "cc"); \ + ret; \ + }) + +#define __encls_ret_1 (rax, rcx) \ + ({ \ + __encls_ret_N(rax, "c"(rcx)); \ + }) + +#define __encls_ret_2 (rax, rbx, rcx) \ + ({ \ + __encls_ret_N(rax, "b"(rbx), "c"(rcx)); \ + }) + +#define __encls_ret_3 (rax, rbx, rcx, rdx) \ + ({ \ + __encls_ret_N(rax, "b"(rbx), "c"(rcx), "d"(rdx)); \ + }) + +/** +* __encls_N - encode an ENCLS function that doesn't return an error code +* @rax: function number +* @rbx_out: optional output variable +* @inputs: asm inputs for the function +* +* Emit assembly for an ENCLS function that does not return an error code, e.g. +* ECREATE. Leaves without error codes either succeed or fault. @rbx_out is an +* optional parameter for use by EDGBRD, which returns the requested value in +* RBX. +* +* Return: +* 0 on success, +* trapnr with ENCLS_FAULT_FLAG set on fault +*/ +#define __encls_N(rax, rbx_out, inputs...) \ + ({ \ + int ret; \ + asm volatile( \ + "1: .byte 0x0f, 0x01, 0xcf;\n\t" \ + " xor %%eax,%%eax;\n" \ + "2:\n" \ + ".section .fixup,\"ax\"\n" \ + "3: orl $"__stringify(ENCLS_FAULT_FLAG)",%%eax\n" \ + " jmp 2b\n" \ + ".previous\n" \ + _ASM_EXTABLE_FAULT(1b, 3b) \ + : "=a"(ret), "=b"(rbx_out) \ + : "a"(rax), inputs \ + : "memory"); \ + ret; \ + }) + +#define __encls_2 (rax, rbx, rcx) \ + ({ \ + unsigned long ign_rbx_out; \ + __encls_N(rax, ign_rbx_out, "b"(rbx), "c"(rcx)); \ + }) + +#define __encls_1_1 (rax, data, rcx) \ + ({ \ + unsigned long rbx_out; \ + int ret = __encls_N(rax, rbx_out, "c"(rcx)); \ + if (!ret) \ + data = rbx_out; \ + ret; \ + }) + +static inline int __ecreate (struct sgx_pageinfo *pginfo,void *secs) +{ +return __encls_2 (ECREATE , pginfo, secs); +} + +static inline int __eextend (void *secs,void *addr) +{ +return __encls_2 (EEXTEND , secs, addr); +} + +static inline int __eadd (struct sgx_pageinfo *pginfo,void *addr) +{ +return __encls_2 (EADD , pginfo, addr); +} + +static inline int __einit (void *sigstruct,void *token,void *secs) +{ +return __encls_ret_3 (EINIT , sigstruct, secs, token); +} + +static inline int __eremove (void *addr) +{ +return __encls_ret_1 (EREMOVE , addr); +} + +static inline int __edbgwr (void *addr,unsigned long *data) +{ +return __encls_2 (EDGBWR , *data, addr); +} + +static inline int __edbgrd (void *addr,unsigned long *data) +{ +return __encls_1_1 (EDGBRD , *data, addr); +} + +static inline int __etrack (void *addr) +{ +return __encls_ret_1 (ETRACK , addr); +} + +static inline int __eldu (struct sgx_pageinfo *pginfo,void *addr, +void *va) +{ +return __encls_ret_3 (ELDU , pginfo, addr, va); +} + +static inline int __eblock (void *addr) +{ +return __encls_ret_1 (EBLOCK , addr); +} + +static inline int __epa (void *addr) +{ +unsigned long rbx =SGX_PAGE_TYPE_VA ; + +return __encls_2 (EPA , rbx, addr); +} + +static inline int __ewb (struct sgx_pageinfo *pginfo,void *addr, +void *va) +{ +return __encls_ret_3 (EWB , pginfo, addr, va); +} + +#endif /* _X86_ENCLS_H */
[tip: x86/sgx] x86/cpufeatures: Add Intel SGX hardware bits
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: e7b6385b01d8e9fb7a97887c3ea649abb95bb8c8 Gitweb: https://git.kernel.org/tip/e7b6385b01d8e9fb7a97887c3ea649abb95bb8c8 Author: Sean Christopherson <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:14 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Tue, 17 Nov 2020 14:36:13 +01:00
x86/cpufeatures: Add Intel SGX hardware bits
Populate X86_FEATURE_SGX feature from CPUID and tie it to the Kconfig option with disabled-features.h.
IA32_FEATURE_CONTROL.SGX_ENABLE must be examined in addition to the CPUID bits to enable full SGX support. The BIOS must both set this bit and lock IA32_FEATURE_CONTROL for SGX to be supported (Intel SDM section 36.7.1). The setting or clearing of this bit has no impact on the CPUID bits above, which is why it needs to be detected separately.
--- arch/x86/include/asm/cpufeatures.h | 1 + arch/x86/include/asm/disabled-features.h | 8 +++++++- arch/x86/include/asm/msr-index.h | 1 + 3 files changed, 9 insertions(+), 1 deletion(-)
arch/x86/include/asm/cpufeatures.h +1 -0
@@ -241,6 +241,7 @@/* Intel-defined CPU features, CPUID level 0x00000007:0 (EBX), word 9 */ #define X86_FEATURE_FSGSBASE ( 9*32+ 0)/* RDFSBASE, WRFSBASE, RDGSBASE, WRGSBASE instructions*/ #define X86_FEATURE_TSC_ADJUST ( 9*32+ 1)/* TSC adjustment MSR 0x3B */ +#define X86_FEATURE_SGX ( 9*32+ 2)/* Software Guard Extensions */ #define X86_FEATURE_BMI1 ( 9*32+ 3)/* 1st group bit manipulation extensions */ #define X86_FEATURE_HLE ( 9*32+ 4)/* Hardware Lock Elision */ #define X86_FEATURE_AVX2 ( 9*32+ 5)/* AVX2 instructions */
arch/x86/include/asm/disabled-features.h +7 -1
@@ -62,6 +62,12 @@# define DISABLE_ENQCMD (1 << (X86_FEATURE_ENQCMD & 31))#endif +#ifdef CONFIG_X86_SGX +# define DISABLE_SGX 0 +#else +# define DISABLE_SGX (1 << (X86_FEATURE_SGX & 31)) +#endif +/* * Make sure to add features to the correct mask */
@@ -74,7 +80,7 @@#define DISABLED_MASK6 0#define DISABLED_MASK7 (DISABLE_PTI)#define DISABLED_MASK8 0 -#define DISABLED_MASK9 (DISABLE_SMAP) +#define DISABLED_MASK9 (DISABLE_SMAP|DISABLE_SGX)#define DISABLED_MASK10 0#define DISABLED_MASK11 0#define DISABLED_MASK12 0
arch/x86/include/asm/msr-index.h +1 -0
@@ -609,6 +609,7 @@#define FEAT_CTL_LOCKED BIT(0)#define FEAT_CTL_VMX_ENABLED_INSIDE_SMX BIT(1)#define FEAT_CTL_VMX_ENABLED_OUTSIDE_SMX BIT(2) +#define FEAT_CTL_SGX_ENABLED BIT(18)#define FEAT_CTL_LMCE_ENABLED BIT(20)#define MSR_IA32_TSC_ADJUST 0x0000003b
[tip: x86/sgx] x86/{cpufeatures,msr}: Add Intel SGX Launch Control hardware bits
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: d205e0f1426e0f99e2b4f387c49f2d8b66e129dd Gitweb: https://git.kernel.org/tip/d205e0f1426e0f99e2b4f387c49f2d8b66e129dd Author: Sean Christopherson <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:15 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Tue, 17 Nov 2020 14:36:13 +01:00
x86/{cpufeatures,msr}: Add Intel SGX Launch Control hardware bits
The SGX Launch Control hardware helps restrict which enclaves the hardware will run. Launch control is intended to restrict what software can run with enclave protections, which helps protect the overall system from bad enclaves.
For the kernel's purposes, there are effectively two modes in which the launch control hardware can operate: rigid and flexible. In its rigid mode, an entity other than the kernel has ultimate authority over which enclaves can be run (firmware, Intel, etc...). In its flexible mode, the kernel has ultimate authority over which enclaves can run.
Enable X86_FEATURE_SGX_LC to enumerate when the CPU supports SGX Launch Control in general.
Add MSR_IA32_SGXLEPUBKEYHASH{0, 1, 2, 3}, which when combined contain a SHA256 hash of a 3072-bit RSA public key. The hardware allows SGX enclaves signed with this public key to initialize and run [*]. Enclaves not signed with this key can not initialize and run.
Add FEAT_CTL_SGX_LC_ENABLED, which informs whether the SGXLEPUBKEYHASH MSRs can be written by the kernel.
If the MSRs do not exist or are read-only, the launch control hardware is operating in rigid mode. Linux does not and will not support creating enclaves when hardware is configured in rigid mode because it takes away the authority for launch decisions from the kernel. Note, this does not preclude KVM from virtualizing/exposing SGX to a KVM guest when launch control hardware is operating in rigid mode.
[*] Intel SDM: 38.1.4 Intel SGX Launch Control Configuration
--- arch/x86/include/asm/cpufeatures.h | 1 + arch/x86/include/asm/msr-index.h | 7 +++++++ 2 files changed, 8 insertions(+)
arch/x86/include/asm/cpufeatures.h +1 -0
@@ -357,6 +357,7 @@#define X86_FEATURE_MOVDIRI (16*32+27)/* MOVDIRI instruction */ #define X86_FEATURE_MOVDIR64B (16*32+28)/* MOVDIR64B instruction */ #define X86_FEATURE_ENQCMD (16*32+29)/* ENQCMD and ENQCMDS instructions */ +#define X86_FEATURE_SGX_LC (16*32+30)/* Software Guard Extensions Launch Control */ /* AMD-defined CPU features, CPUID level 0x80000007 (EBX), word 17 */ #define X86_FEATURE_OVERFLOW_RECOV (17*32+ 0)/* MCA overflow recovery support */
arch/x86/include/asm/msr-index.h +7 -0
@@ -609,6 +609,7 @@#define FEAT_CTL_LOCKED BIT(0)#define FEAT_CTL_VMX_ENABLED_INSIDE_SMX BIT(1)#define FEAT_CTL_VMX_ENABLED_OUTSIDE_SMX BIT(2) +#define FEAT_CTL_SGX_LC_ENABLED BIT(17)#define FEAT_CTL_SGX_ENABLED BIT(18)#define FEAT_CTL_LMCE_ENABLED BIT(20)
@@ -629,6 +630,12 @@#define MSR_IA32_UCODE_WRITE 0x00000079#define MSR_IA32_UCODE_REV 0x0000008b +/* Intel SGX Launch Enclave Public Key Hash MSRs */ +#define MSR_IA32_SGXLEPUBKEYHASH0 0x0000008C +#define MSR_IA32_SGXLEPUBKEYHASH1 0x0000008D +#define MSR_IA32_SGXLEPUBKEYHASH2 0x0000008E +#define MSR_IA32_SGXLEPUBKEYHASH3 0x0000008F +#define MSR_IA32_SMM_MONITOR_CTL 0x0000009b#define MSR_IA32_SMBASE 0x0000009e
[tip: x86/sgx] x86/sgx: Initialize metadata for Enclave Page Cache (EPC) sections
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: e7e0545299d8cb0fd6fe3ba50401b7f5c3937362 Gitweb: https://git.kernel.org/tip/e7e0545299d8cb0fd6fe3ba50401b7f5c3937362 Author: Sean Christopherson <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:16 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Tue, 17 Nov 2020 14:36:13 +01:00
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.
--- arch/x86/Kconfig | 17 +++- arch/x86/kernel/cpu/Makefile | 1 +- arch/x86/kernel/cpu/sgx/Makefile | 2 +- arch/x86/kernel/cpu/sgx/main.c | 190 ++++++++++++++++++++++++++++++- arch/x86/kernel/cpu/sgx/sgx.h | 60 +++++++++- 5 files changed, 270 insertions(+) create mode 100644 arch/x86/kernel/cpu/sgx/Makefile create mode 100644 arch/x86/kernel/cpu/sgx/main.c create mode 100644 arch/x86/kernel/cpu/sgx/sgx.h
arch/x86/Kconfig +17 -0
@@ -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
arch/x86/kernel/cpu/Makefile +1 -0
@@ -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
arch/x86/kernel/cpu/sgx/Makefile new file +2 -0
@@ -0,0 +1,2 @@ +obj-y += \ + main.o
arch/x86/kernel/cpu/sgx/main.c new file +190 -0
190 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/sgx.h new file +60 -0
60 lines not on this page · raw message
[tip: x86/sgx] x86/sgx: Add SGX architectural data structures
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 70d3b8ddcd20d3c859676f56c43c7b2360c70266 Gitweb: https://git.kernel.org/tip/70d3b8ddcd20d3c859676f56c43c7b2360c70266 Author: Jarkko Sakkinen <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:12 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Tue, 17 Nov 2020 14:36:12 +01:00
x86/sgx: Add SGX architectural data structures
Define the SGX architectural data structures used by various SGX functions. This is not an exhaustive representation of all SGX data structures but only those needed by the kernel.
The goal is to sequester hardware structures in "sgx/arch.h" and keep them separate from kernel-internal or uapi structures.
The data structures are described in Intel SDM section 37.6.
--- arch/x86/kernel/cpu/sgx/arch.h | 338 ++++++++++++++++++++++++++++++++- 1 file changed, 338 insertions(+) create mode 100644 arch/x86/kernel/cpu/sgx/arch.h
arch/x86/kernel/cpu/sgx/arch.h new file +338 -0
@@ -0,0 +1,338 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/** +* Copyright(c) 2016-20 Intel Corporation. +* +* Contains data structures defined by the SGX architecture. Data structures +* defined by the Linux software stack should not be placed here. +*/ +#ifndef _ASM_X86_SGX_ARCH_H +#define _ASM_X86_SGX_ARCH_H + +#include <linux/bits.h> +#include <linux/types.h> + +/* The SGX specific CPUID function. */ +#define SGX_CPUID 0x12 +/* EPC enumeration. */ +#define SGX_CPUID_EPC 2 +/* An invalid EPC section, i.e. the end marker. */ +#define SGX_CPUID_EPC_INVALID 0x0 +/* A valid EPC section. */ +#define SGX_CPUID_EPC_SECTION 0x1 +/* The bitmask for the EPC section type. */ +#define SGX_CPUID_EPC_MASK GENMASK(3, 0) + +/** +* enum sgx_return_code - The return code type for ENCLS, ENCLU and ENCLV +* %SGX_NOT_TRACKED: Previous ETRACK's shootdown sequence has not +* been completed yet. +* %SGX_INVALID_EINITTOKEN: EINITTOKEN is invalid and enclave signer's +* public key does not match IA32_SGXLEPUBKEYHASH. +* %SGX_UNMASKED_EVENT: An unmasked event, e.g. INTR, was received +*/ +enum sgx_return_code { +SGX_NOT_TRACKED =11 , +SGX_INVALID_EINITTOKEN =16 , +SGX_UNMASKED_EVENT =128 , +}; + +/* The modulus size for 3072-bit RSA keys. */ +#define SGX_MODULUS_SIZE 384 + +/** +* enum sgx_miscselect - additional information to an SSA frame +* %SGX_MISC_EXINFO: Report #PF or #GP to the SSA frame. +* +* Save State Area (SSA) is a stack inside the enclave used to store processor +* state when an exception or interrupt occurs. This enum defines additional +* information stored to an SSA frame. +*/ +enum sgx_miscselect { +SGX_MISC_EXINFO =BIT (0 ), +}; + +#define SGX_MISC_RESERVED_MASK GENMASK_ULL(63, 1) + +#define SGX_SSA_GPRS_SIZE 184 +#define SGX_SSA_MISC_EXINFO_SIZE 16 + +/** +* enum sgx_attributes - the attributes field in &struct sgx_secs +* %SGX_ATTR_INIT: Enclave can be entered (is initialized). +* %SGX_ATTR_DEBUG: Allow ENCLS(EDBGRD) and ENCLS(EDBGWR). +* %SGX_ATTR_MODE64BIT: Tell that this a 64-bit enclave. +* %SGX_ATTR_PROVISIONKEY: Allow to use provisioning keys for remote +* attestation. +* %SGX_ATTR_KSS: Allow to use key separation and sharing (KSS). +* %SGX_ATTR_EINITTOKENKEY: Allow to use token signing key that is used to +* sign cryptographic tokens that can be passed to +* EINIT as an authorization to run an enclave. +*/ +enum sgx_attribute { +SGX_ATTR_INIT =BIT (0 ), +SGX_ATTR_DEBUG =BIT (1 ), +SGX_ATTR_MODE64BIT =BIT (2 ), +SGX_ATTR_PROVISIONKEY =BIT (4 ), +SGX_ATTR_EINITTOKENKEY =BIT (5 ), +SGX_ATTR_KSS =BIT (7 ), +}; + +#define SGX_ATTR_RESERVED_MASK (BIT_ULL(3) | BIT_ULL(6) | GENMASK_ULL(63, 8)) + +/** +* struct sgx_secs - SGX Enclave Control Structure (SECS) +* @size: size of the address space +* @base: base address of the address space +* @ssa_frame_size: size of an SSA frame +* @miscselect: additional information stored to an SSA frame +* @attributes: attributes for enclave +* @xfrm: XSave-Feature Request Mask (subset of XCR0) +* @mrenclave: SHA256-hash of the enclave contents +* @mrsigner: SHA256-hash of the public key used to sign the SIGSTRUCT +* @config_id: a user-defined value that is used in key derivation +* @isv_prod_id: a user-defined value that is used in key derivation +* @isv_svn: a user-defined value that is used in key derivation +* @config_svn: a user-defined value that is used in key derivation +* +* SGX Enclave Control Structure (SECS) is a special enclave page that is not +* visible in the address space. In fact, this structure defines the address +* range and other global attributes for the enclave and it is the first EPC +* page created for any enclave. It is moved from a temporary buffer to an EPC +* by the means of ENCLS[ECREATE] function. +*/ +struct sgx_secs { +u64 size; +u64 base; +u32 ssa_frame_size; +u32 miscselect; +u8 reserved1[24 ]; +u64 attributes; +u64 xfrm; +u32 mrenclave[8 ]; +u8 reserved2[32 ]; +u32 mrsigner[8 ]; +u8 reserved3[32 ]; +u32 config_id[16 ]; +u16 isv_prod_id; +u16 isv_svn; +u16 config_svn; +u8 reserved4[3834 ]; +} __packed; + +/** +* enum sgx_tcs_flags - execution flags for TCS +* %SGX_TCS_DBGOPTIN: If enabled allows single-stepping and breakpoints +* inside an enclave. It is cleared by EADD but can +* be set later with EDBGWR. +*/ +enum sgx_tcs_flags { +SGX_TCS_DBGOPTIN =0x01 , +}; + +#define SGX_TCS_RESERVED_MASK GENMASK_ULL(63, 1) +#define SGX_TCS_RESERVED_SIZE 4024 + +/** +* struct sgx_tcs - Thread Control Structure (TCS) +* @state: used to mark an entered TCS +* @flags: execution flags (cleared by EADD) +* @ssa_offset: SSA stack offset relative to the enclave base +* @ssa_index: the current SSA frame index (cleard by EADD) +* @nr_ssa_frames: the number of frame in the SSA stack +* @entry_offset: entry point offset relative to the enclave base +* @exit_addr: address outside the enclave to exit on an exception or +* interrupt +* @fs_offset: offset relative to the enclave base to become FS +* segment inside the enclave +* @gs_offset: offset relative to the enclave base to become GS +* segment inside the enclave +* @fs_limit: size to become a new FS-limit (only 32-bit enclaves) +* @gs_limit: size to become a new GS-limit (only 32-bit enclaves) +* +* Thread Control Structure (TCS) is an enclave page visible in its address +* space that defines an entry point inside the enclave. A thread enters inside +* an enclave by supplying address of TCS to ENCLU(EENTER). A TCS can be entered +* by only one thread at a time. +*/ +struct sgx_tcs { +u64 state; +u64 flags; +u64 ssa_offset; +u32 ssa_index; +u32 nr_ssa_frames; +u64 entry_offset; +u64 exit_addr; +u64 fs_offset; +u64 gs_offset; +u32 fs_limit; +u32 gs_limit; +u8 reserved[SGX_TCS_RESERVED_SIZE ]; +} __packed; + +/** +* struct sgx_pageinfo - an enclave page descriptor +* @addr: address of the enclave page +* @contents: pointer to the page contents +* @metadata: pointer either to a SECINFO or PCMD instance +* @secs: address of the SECS page +*/ +struct sgx_pageinfo { +u64 addr; +u64 contents; +u64 metadata; +u64 secs; +} __packed__aligned(32) ; + + +/** +* enum sgx_page_type - bits in the SECINFO flags defining the page type +* %SGX_PAGE_TYPE_SECS: a SECS page +* %SGX_PAGE_TYPE_TCS: a TCS page +* %SGX_PAGE_TYPE_REG: a regular page +* %SGX_PAGE_TYPE_VA: a VA page +* %SGX_PAGE_TYPE_TRIM: a page in trimmed state +*/ +enum sgx_page_type { +SGX_PAGE_TYPE_SECS , +SGX_PAGE_TYPE_TCS , +SGX_PAGE_TYPE_REG , +SGX_PAGE_TYPE_VA , +SGX_PAGE_TYPE_TRIM , +}; + +#define SGX_NR_PAGE_TYPES 5 +#define SGX_PAGE_TYPE_MASK GENMASK(7, 0) + +/** +* enum sgx_secinfo_flags - the flags field in &struct sgx_secinfo +* %SGX_SECINFO_R: allow read +* %SGX_SECINFO_W: allow write +* %SGX_SECINFO_X: allow execution +* %SGX_SECINFO_SECS: a SECS page +* %SGX_SECINFO_TCS: a TCS page +* %SGX_SECINFO_REG: a regular page +* %SGX_SECINFO_VA: a VA page +* %SGX_SECINFO_TRIM: a page in trimmed state +*/ +enum sgx_secinfo_flags { +SGX_SECINFO_R =BIT (0 ), +SGX_SECINFO_W =BIT (1 ), +SGX_SECINFO_X =BIT (2 ), +SGX_SECINFO_SECS = (SGX_PAGE_TYPE_SECS <<8 ), +SGX_SECINFO_TCS = (SGX_PAGE_TYPE_TCS <<8 ), +SGX_SECINFO_REG = (SGX_PAGE_TYPE_REG <<8 ), +SGX_SECINFO_VA = (SGX_PAGE_TYPE_VA <<8 ), +SGX_SECINFO_TRIM = (SGX_PAGE_TYPE_TRIM <<8 ), +}; + +#define SGX_SECINFO_PERMISSION_MASK GENMASK_ULL(2, 0) +#define SGX_SECINFO_PAGE_TYPE_MASK (SGX_PAGE_TYPE_MASK << 8) +#define SGX_SECINFO_RESERVED_MASK ~(SGX_SECINFO_PERMISSION_MASK | \ + SGX_SECINFO_PAGE_TYPE_MASK) + +/** +* struct sgx_secinfo - describes attributes of an EPC page +* @flags: permissions and type +* +* Used together with ENCLS leaves that add or modify an EPC page to an +* enclave to define page permissions and type. +*/ +struct sgx_secinfo { +u64 flags; +u8 reserved[56 ]; +} __packed__aligned(64) ; + +#define SGX_PCMD_RESERVED_SIZE 40 + +/** +* struct sgx_pcmd - Paging Crypto Metadata (PCMD) +* @enclave_id: enclave identifier +* @mac: MAC over PCMD, page contents and isvsvn +* +* PCMD is stored for every swapped page to the regular memory. When ELDU loads +* the page back it recalculates the MAC by using a isvsvn number stored in a +* VA page. Together these two structures bring integrity and rollback +* protection. +*/ +struct sgx_pcmd { +struct sgx_secinfo secinfo; +u64 enclave_id; +u8 reserved[SGX_PCMD_RESERVED_SIZE ]; +u8 mac[16 ]; +} __packed__aligned(128) ; + +#define SGX_SIGSTRUCT_RESERVED1_SIZE 84 +#define SGX_SIGSTRUCT_RESERVED2_SIZE 20 +#define SGX_SIGSTRUCT_RESERVED3_SIZE 32 +#define SGX_SIGSTRUCT_RESERVED4_SIZE 12 + +/** +* struct sgx_sigstruct_header - defines author of the enclave +* @header1: constant byte string +* @vendor: must be either 0x0000 or 0x8086 +* @date: YYYYMMDD in BCD +* @header2: costant byte string +* @swdefined: software defined value +*/ +struct sgx_sigstruct_header { +u64 header1[2 ]; +u32 vendor; +u32 date; +u64 header2[2 ]; +u32 swdefined; +u8 reserved1[84 ]; +} __packed; + +/** +* struct sgx_sigstruct_body - defines contents of the enclave +* @miscselect: additional information stored to an SSA frame +* @misc_mask: required miscselect in SECS +* @attributes: attributes for enclave +* @xfrm: XSave-Feature Request Mask (subset of XCR0) +* @attributes_mask: required attributes in SECS +* @xfrm_mask: required XFRM in SECS +* @mrenclave: SHA256-hash of the enclave contents +* @isvprodid: a user-defined value that is used in key derivation +* @isvsvn: a user-defined value that is used in key derivation +*/ +struct sgx_sigstruct_body { +u32 miscselect; +u32 misc_mask; +u8 reserved2[20 ]; +u64 attributes; +u64 xfrm; +u64 attributes_mask; +u64 xfrm_mask; +u8 mrenclave[32 ]; +u8 reserved3[32 ]; +u16 isvprodid; +u16 isvsvn; +} __packed; + +/** +* struct sgx_sigstruct - an enclave signature +* @header: defines author of the enclave +* @modulus: the modulus of the public key +* @exponent: the exponent of the public key +* @signature: the signature calculated over the fields except modulus, +* @body: defines contents of the enclave +* @q1: a value used in RSA signature verification +* @q2: a value used in RSA signature verification +* +* Header and body are the parts that are actual signed. The remaining fields +* define the signature of the enclave. +*/ +struct sgx_sigstruct { +struct sgx_sigstruct_header header; +u8 modulus[SGX_MODULUS_SIZE ]; +u32 exponent; +u8 signature[SGX_MODULUS_SIZE ]; +struct sgx_sigstruct_body body; +u8 reserved4[12 ]; +u8 q1[SGX_MODULUS_SIZE ]; +u8 q2[SGX_MODULUS_SIZE ]; +} __packed; + +#define SGX_LAUNCH_TOKEN_SIZE 304 + +#endif /* _ASM_X86_SGX_ARCH_H */
[tip: x86/sgx] x86/mm: Signal SIGSEGV with PF_SGX
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 74faeee06db81a06add0def6a394210c8fef0ab7 Gitweb: https://git.kernel.org/tip/74faeee06db81a06add0def6a394210c8fef0ab7 Author: Sean Christopherson <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:17 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Tue, 17 Nov 2020 14:36:13 +01:00
x86/mm: Signal SIGSEGV with PF_SGX
The x86 architecture has a set of page fault error codes. These indicate things like whether the fault occurred from a write, or whether it originated in userspace.
The SGX hardware architecture has its own per-page memory management metadata (EPCM) [*] and hardware which is separate from the normal x86 MMU. The architecture has a new page fault error code: PF_SGX. This new error code bit is set whenever a page fault occurs as the result of the SGX MMU.
These faults occur for a variety of reasons. For instance, an access attempt to enclave memory from outside the enclave causes a PF_SGX fault. PF_SGX would also be set for permission conflicts, such as if a write to an enclave page occurs and the page is marked read-write in the x86 page tables but is read-only in the EPCM.
These faults do not always indicate errors, though. SGX pages are encrypted with a key that is destroyed at hardware reset, including suspend. Throwing a SIGSEGV allows user space software to react and recover when these events occur.
Include PF_SGX in the PF error codes list and throw SIGSEGV when it is encountered.
[*] Intel SDM: 36.5.1 Enclave Page Cache Map (EPCM)
[ bp: Add bit 15 to the comment above enum x86_pf_error_code too. ]
--- arch/x86/include/asm/trap_pf.h | 2 ++ arch/x86/mm/fault.c | 12 ++++++++++++ 2 files changed, 14 insertions(+)
arch/x86/include/asm/trap_pf.h +2 -0
@@ -11,6 +11,7 @@* bit 3 == 1: use of reserved bit detected * bit 4 == 1: fault was an instruction fetch * bit 5 == 1: protection keys block access +* bit 15 == 1: SGX MMU page-fault */ enum x86_pf_error_code {X86_PF_PROT =1 <<0 ,
@@ -19,6 +20,7 @@ enum x86_pf_error_code {X86_PF_RSVD =1 <<3 ,X86_PF_INSTR =1 <<4 ,X86_PF_PK =1 <<5 , + X86_PF_SGX = 1 << 15, };#endif /* _ASM_X86_TRAP_PF_H */
arch/x86/mm/fault.c +12 -0
@@ -1102,6 +1102,18 @@ access_error(unsigned long error_code, struct vm_area_struct *vma)return 1 ;/* +* SGX hardware blocked the access. This usually happens +* when the enclave memory contents have been destroyed, like +* after a suspend/resume cycle. In any case, the kernel can't +* fix the cause of the fault. Handle the fault as an access +* error even in cases where no actual access violation +* occurred. This allows userspace to rebuild the enclave in +* response to the signal. +*/ +if (unlikely (error_code &X86_PF_SGX )) +return 1 ; + +/* * Make sure to check the VMA so that we do not perform * faults just to hit a X86_PF_PK as soon as we fill in a * page.
[tip: x86/sgx] x86/cpu/intel: Detect SGX support
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 224ab3527f89f69ae57dc53555826667ac46a3cc Gitweb: https://git.kernel.org/tip/224ab3527f89f69ae57dc53555826667ac46a3cc Author: Sean Christopherson <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:18 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Tue, 17 Nov 2020 14:36:13 +01:00
x86/cpu/intel: Detect SGX support
Kernel support for SGX is ultimately decided by the state of the launch control bits in the feature control MSR (MSR_IA32_FEAT_CTL). If the hardware supports SGX, but neglects to support flexible launch control, the kernel will not enable SGX.
Enable SGX at feature control MSR initialization and update the associated X86_FEATURE flags accordingly. Disable X86_FEATURE_SGX (and all derivatives) if the kernel is not able to establish itself as the authority over SGX Launch Control.
All checks are performed for each logical CPU (not just boot CPU) in order to verify that MSR_IA32_FEATURE_CONTROL is correctly configured on all CPUs. All SGX code in this series expects the same configuration from all CPUs.
This differs from VMX where X86_FEATURE_VMX is intentionally cleared only for the current CPU so that KVM can provide additional information if KVM fails to load like which CPU doesn't support VMX. There’s not much the kernel or an administrator can do to fix the situation, so SGX neglects to convey additional details about these kinds of failures if they occur.
--- arch/x86/kernel/cpu/feat_ctl.c | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-)
arch/x86/kernel/cpu/feat_ctl.c +28 -1
@@ -93,16 +93,32 @@ static void init_vmx_capabilities(struct cpuinfo_x86 *c) }#endif /* CONFIG_X86_VMX_FEATURE_NAMES */ +static void clear_sgx_caps (void ) +{ +setup_clear_cpu_cap (X86_FEATURE_SGX ); +setup_clear_cpu_cap (X86_FEATURE_SGX_LC ); +} +void init_ia32_feat_ctl (struct cpuinfo_x86 *c) {bool tboot =tboot_enabled (); +bool enable_sgx;u64 msr;if (rdmsrl_safe (MSR_IA32_FEAT_CTL , &msr)) {clear_cpu_cap (c,X86_FEATURE_VMX ); +clear_sgx_caps ();return ; } +/* +* Enable SGX if and only if the kernel supports SGX and Launch Control +* is supported, i.e. disable SGX if the LE hash MSRs can't be written. +*/ + enable_sgx =cpu_has (c,X86_FEATURE_SGX ) && +cpu_has (c,X86_FEATURE_SGX_LC ) && +IS_ENABLED (CONFIG_X86_SGX ); +if (msr &FEAT_CTL_LOCKED ) goto update_caps;
@@ -124,13 +140,16 @@ void init_ia32_feat_ctl(struct cpuinfo_x86 *c) msr |=FEAT_CTL_VMX_ENABLED_INSIDE_SMX ; } +if (enable_sgx) + msr |=FEAT_CTL_SGX_ENABLED |FEAT_CTL_SGX_LC_ENABLED ; +wrmsrl (MSR_IA32_FEAT_CTL , msr); update_caps:set_cpu_cap (c,X86_FEATURE_MSR_IA32_FEAT_CTL );if (!cpu_has (c,X86_FEATURE_VMX )) -return ; + goto update_sgx;if ( (tboot && !(msr &FEAT_CTL_VMX_ENABLED_INSIDE_SMX )) || (!tboot && !(msr &FEAT_CTL_VMX_ENABLED_OUTSIDE_SMX ))) {
@@ -143,4 +162,12 @@ update_caps:init_vmx_capabilities (c);#endif } + +update_sgx: +if (!(msr &FEAT_CTL_SGX_ENABLED ) || + !(msr &FEAT_CTL_SGX_LC_ENABLED ) || !enable_sgx) { +if (enable_sgx) +pr_err_once ("SGX disabled by BIOS\n" ); +clear_sgx_caps (); + } }
[tip: x86/sgx] x86/sgx: Add an SGX misc driver interface
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 3fe0778edac8628637e2fd23835996523b1a3372 Gitweb: https://git.kernel.org/tip/3fe0778edac8628637e2fd23835996523b1a3372 Author: Jarkko Sakkinen <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:22 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Wed, 18 Nov 2020 18:01:16 +01:00
x86/sgx: Add an SGX misc driver interface
Intel(R) SGX is a new hardware functionality that can be used by applications to set aside private regions of code and data called enclaves. New hardware protects enclave code and data from outside access and modification.
Add a driver that presents a device file and ioctl API to build and manage enclaves.
[ bp: Small touchups, remove unused encl variable in sgx_encl_find() as
--- arch/x86/kernel/cpu/sgx/Makefile | 2 +- arch/x86/kernel/cpu/sgx/driver.c | 112 +++++++++++++++++++++++- arch/x86/kernel/cpu/sgx/driver.h | 16 +++- arch/x86/kernel/cpu/sgx/encl.c | 146 ++++++++++++++++++++++++++++++- arch/x86/kernel/cpu/sgx/encl.h | 58 ++++++++++++- arch/x86/kernel/cpu/sgx/main.c | 12 +- 6 files changed, 345 insertions(+), 1 deletion(-) create mode 100644 arch/x86/kernel/cpu/sgx/driver.c create mode 100644 arch/x86/kernel/cpu/sgx/driver.h create mode 100644 arch/x86/kernel/cpu/sgx/encl.c create mode 100644 arch/x86/kernel/cpu/sgx/encl.h
arch/x86/kernel/cpu/sgx/Makefile +2 -0
@@ -1,2 +1,4 @@ obj-y += \ + driver.o \ + encl.o \ main.o
arch/x86/kernel/cpu/sgx/driver.c new file +112 -0
112 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/driver.h new file +16 -0
@@ -0,0 +1,16 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __ARCH_SGX_DRIVER_H__ +#define __ARCH_SGX_DRIVER_H__ + +#include <crypto/hash.h> +#include <linux/kref.h> +#include <linux/mmu_notifier.h> +#include <linux/radix-tree.h> +#include <linux/rwsem.h> +#include <linux/sched.h> +#include <linux/workqueue.h> +#include "sgx.h" + +int sgx_drv_init (void ); + +#endif /* __ARCH_X86_SGX_DRIVER_H__ */
arch/x86/kernel/cpu/sgx/encl.c new file +146 -0
146 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/encl.h new file +58 -0
58 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/main.c +11 -1
@@ -9,6 +9,8 @@#include <linux/sched/mm.h> #include <linux/sched/signal.h> #include <linux/slab.h> +#include "driver.h" +#include "encl.h" #include "encls.h" struct sgx_epc_section sgx_epc_sections[SGX_MAX_EPC_SECTIONS ];
@@ -232,9 +234,10 @@ static bool __init sgx_page_cache_init(void)static void __init sgx_init (void ) { +int ret;int i; -if (!boot_cpu_has (X86_FEATURE_SGX )) +if (!cpu_feature_enabled (X86_FEATURE_SGX ))return ;if (!sgx_page_cache_init ())
@@ -243,8 +246,15 @@ static void __init sgx_init(void)if (!sgx_page_reclaimer_init ()) goto err_page_cache; + ret =sgx_drv_init (); +if (ret) + goto err_kthread; +return ; +err_kthread: +kthread_stop (ksgxd_tsk); + err_page_cache:for (i =0 ; i < sgx_nr_epc_sections; i++) {vfree (sgx_epc_sections[i].pages);
[tip: x86/sgx] x86/fault: Add a helper function to sanitize error code
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: cd072dab453a9b4a9f7927f9eddca5a156fbd87d Gitweb: https://git.kernel.org/tip/cd072dab453a9b4a9f7927f9eddca5a156fbd87d Author: Sean Christopherson <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:28 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Wed, 18 Nov 2020 18:02:50 +01:00
x86/fault: Add a helper function to sanitize error code
vDSO exception fixup is a replacement for signals in limited situations. Signals and vDSO exception fixup need to provide similar information to userspace, including the hardware error code.
That hardware error code needs to be sanitized. For instance, if userspace accesses a kernel address, the error code could indicate to userspace whether the address had a Present=1 PTE. That can leak information about the kernel layout to userspace, which is bad.
The existing signal code does this sanitization, but fairly late in the signal process. The vDSO exception code runs before the sanitization happens.
Move error code sanitization out of the signal code and into a helper. Call the helper in the signal code.
--- arch/x86/mm/fault.c | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-)
arch/x86/mm/fault.c +14 -12
@@ -602,11 +602,9 @@ pgtable_bad(struct pt_regs *regs, unsigned long error_code,oops_end (flags, regs, sig); } -static void set_signal_archinfo (unsigned long address, -unsigned long error_code) +static void sanitize_error_code (unsigned long address, +unsigned long *error_code) { -struct task_struct *tsk = current; -/* * To avoid leaking information about the kernel page * table layout, pretend that user-mode accesses to
@@ -617,7 +615,13 @@ static void set_signal_archinfo(unsigned long address,* information and does not appear to cause any problems. */ if (address >=TASK_SIZE_MAX ) - error_code |=X86_PF_PROT ; + *error_code |=X86_PF_PROT ; +} + +static void set_signal_archinfo (unsigned long address, +unsigned long error_code) +{ +struct task_struct *tsk = current; tsk->thread.trap_nr =X86_TRAP_PF ; tsk->thread.error_code = error_code |X86_PF_USER ;
@@ -658,6 +662,8 @@ no_context(struct pt_regs *regs, unsigned long error_code,* faulting through the emulate_vsyscall() logic. */ if (current->thread.sig_on_uaccess_err && signal) { +sanitize_error_code (address, &error_code); +set_signal_archinfo (address, error_code);/* XXX: hwpoison faults will set the wrong code. */
@@ -806,13 +812,7 @@ __bad_area_nosemaphore(struct pt_regs *regs, unsigned long error_code,if (is_errata100 (regs, address))return ; -/* -* To avoid leaking information about the kernel page table -* layout, pretend that user-mode accesses to kernel addresses -* are always protection faults. -*/ -if (address >=TASK_SIZE_MAX ) - error_code |=X86_PF_PROT ; +sanitize_error_code (address, &error_code);if (likely (show_unhandled_signals))show_signal_msg (regs, error_code, address, tsk);
@@ -931,6 +931,8 @@ do_sigbus(struct pt_regs *regs, unsigned long error_code, unsigned long address,if (is_prefetch (regs, error_code, address))return ; +sanitize_error_code (address, &error_code); +set_signal_archinfo (address, error_code);#ifdef CONFIG_MEMORY_FAILURE
[tip: x86/sgx] x86/traps: Attempt to fixup exceptions in vDSO before signaling
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 334872a0919890a70cccd00b8e11931020a819be Gitweb: https://git.kernel.org/tip/334872a0919890a70cccd00b8e11931020a819be Author: Sean Christopherson <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:29 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Wed, 18 Nov 2020 18:02:50 +01:00
x86/traps: Attempt to fixup exceptions in vDSO before signaling
vDSO functions can now leverage an exception fixup mechanism similar to kernel exception fixup. For vDSO exception fixup, the initial user is Intel's Software Guard Extensions (SGX), which will wrap the low-level transitions to/from the enclave, i.e. EENTER and ERESUME instructions, in a vDSO function and leverage fixup to intercept exceptions that would otherwise generate a signal. This allows the vDSO wrapper to return the fault information directly to its caller, obviating the need for SGX applications and libraries to juggle signal handlers.
Attempt to fixup vDSO exceptions immediately prior to populating and sending signal information. Except for the delivery mechanism, an exception in a vDSO function should be treated like any other exception in userspace, e.g. any fault that is successfully handled by the kernel should not be directly visible to userspace.
Although it's debatable whether or not all exceptions are of interest to enclaves, defer to the vDSO fixup to decide whether to do fixup or generate a signal. Future users of vDSO fixup, if there ever are any, will undoubtedly have different requirements than SGX enclaves, e.g. the fixup vs. signal logic can be made function specific if/when necessary.
--- arch/x86/kernel/traps.c | 10 ++++++++++ arch/x86/mm/fault.c | 7 +++++++ 2 files changed, 17 insertions(+)
arch/x86/kernel/traps.c +10 -0
@@ -60,6 +60,7 @@#include <asm/umip.h> #include <asm/insn.h> #include <asm/insn-eval.h> +#include <asm/vdso.h> #ifdef CONFIG_X86_64 #include <asm/x86_init.h>
@@ -117,6 +118,9 @@ do_trap_no_signal(struct task_struct *tsk, int trapnr, const char *str, tsk->thread.error_code = error_code; tsk->thread.trap_nr = trapnr;die (str, regs, error_code); + }else { +if (fixup_vdso_exception (regs, trapnr, error_code,0 )) +return 0 ; }/*
@@ -550,6 +554,9 @@ DEFINE_IDTENTRY_ERRORCODE(exc_general_protection) tsk->thread.error_code = error_code; tsk->thread.trap_nr =X86_TRAP_GP ; +if (fixup_vdso_exception (regs,X86_TRAP_GP , error_code,0 )) +return ; +show_signal (tsk,SIGSEGV ,"" , desc, regs, error_code);force_sig (SIGSEGV ); goto exit;
@@ -1048,6 +1055,9 @@ static void math_error(struct pt_regs *regs, int trapnr)if (!si_code) goto exit; +if (fixup_vdso_exception (regs, trapnr,0 ,0 )) +return ; +force_sig_fault (SIGFPE , si_code, (void __user *)uprobe_get_trap_addr (regs)); exit:
arch/x86/mm/fault.c +7 -0
@@ -30,6 +30,7 @@#include <asm/cpu_entry_area.h> /* exception stack */ #include <asm/pgtable_areas.h> /* VMALLOC_START, ... */ #include <asm/kvm_para.h> /* kvm_handle_async_pf */ +#include <asm/vdso.h> /* fixup_vdso_exception() */ #define CREATE_TRACE_POINTS #include <asm/trace/exceptions.h>
@@ -814,6 +815,9 @@ __bad_area_nosemaphore(struct pt_regs *regs, unsigned long error_code,sanitize_error_code (address, &error_code); +if (fixup_vdso_exception (regs,X86_TRAP_PF , error_code, address)) +return ; +if (likely (show_unhandled_signals))show_signal_msg (regs, error_code, address, tsk);
@@ -933,6 +937,9 @@ do_sigbus(struct pt_regs *regs, unsigned long error_code, unsigned long address,sanitize_error_code (address, &error_code); +if (fixup_vdso_exception (regs,X86_TRAP_PF , error_code, address)) +return ; +set_signal_archinfo (address, error_code);#ifdef CONFIG_MEMORY_FAILURE
[tip: x86/sgx] x86/sgx: Add SGX page allocator functions
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: d2285493bef310b66b56dfe4eb75c1e2f431ea5c Gitweb: https://git.kernel.org/tip/d2285493bef310b66b56dfe4eb75c1e2f431ea5c Author: Jarkko Sakkinen <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:20 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Tue, 17 Nov 2020 14:36:13 +01:00
x86/sgx: Add SGX page allocator functions
Add functions for runtime allocation and free.
This allocator and its algorithms are as simple as it gets. They do a linear search across all EPC sections and find the first free page. They are not NUMA-aware and only hand out individual pages. The SGX hardware does not support large pages, so something more complicated like a buddy allocator is unwarranted.
The free function (sgx_free_epc_page()) implicitly calls ENCLS[EREMOVE], which returns the page to the uninitialized state. This ensures that the page is ready for use at the next allocation.
--- arch/x86/kernel/cpu/sgx/main.c | 65 +++++++++++++++++++++++++++++++++- arch/x86/kernel/cpu/sgx/sgx.h | 3 ++- 2 files changed, 68 insertions(+)
arch/x86/kernel/cpu/sgx/main.c +65 -0
@@ -85,6 +85,71 @@ static bool __init sgx_page_reclaimer_init(void)return true; } +static struct sgx_epc_page *__sgx_alloc_epc_page_from_section (struct sgx_epc_section *section) +{ +struct sgx_epc_page *page; + +spin_lock (§ion->lock); + +if (list_empty (§ion->page_list)) { +spin_unlock (§ion->lock); +return NULL ; + } + + page = list_first_entry(§ion->page_list, struct sgx_epc_page, list); +list_del_init (&page->list); + +spin_unlock (§ion->lock); +return page; +} + +/** +* __sgx_alloc_epc_page() - Allocate an EPC page +* +* Iterate through EPC sections and borrow a free EPC page to the caller. When a +* page is no longer needed it must be released with sgx_free_epc_page(). +* +* Return: +* an EPC page, +* -errno on error +*/ +struct sgx_epc_page *__sgx_alloc_epc_page (void ) +{ +struct sgx_epc_section *section; +struct sgx_epc_page *page; +int i; + +for (i =0 ; i < sgx_nr_epc_sections; i++) { + section = &sgx_epc_sections[i]; + + page =__sgx_alloc_epc_page_from_section (section); +if (page) +return page; + } + +return ERR_PTR (-ENOMEM ); +} + +/** +* sgx_free_epc_page() - Free an EPC page +* @page: an EPC page +* +* Call EREMOVE for an EPC page and insert it back to the list of free pages. +*/ +void sgx_free_epc_page (struct sgx_epc_page *page) +{ +struct sgx_epc_section *section = &sgx_epc_sections[page->section]; +int ret; + + ret =__eremove (sgx_get_epc_virt_addr (page)); +if (WARN_ONCE (ret,"EREMOVE returned %d (0x%x)" , ret, ret)) +return ; + +spin_lock (§ion->lock); +list_add_tail (&page->list, §ion->page_list); +spin_unlock (§ion->lock); +} +static bool __init sgx_setup_epc_section (u64 phys_addr,u64 size,unsigned long index,struct sgx_epc_section *section)
arch/x86/kernel/cpu/sgx/sgx.h +3 -0
@@ -57,4 +57,7 @@ static inline void *sgx_get_epc_virt_addr(struct sgx_epc_page *page) return section->virt_addr + index * PAGE_SIZE; } +struct sgx_epc_page *__sgx_alloc_epc_page (void ); +void sgx_free_epc_page (struct sgx_epc_page *page); +#endif /* _X86_SGX_H */
[tip: x86/sgx] x86/sgx: Add SGX_IOC_ENCLAVE_CREATE
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 888d249117876239593fe3039b6ead8ad6849035 Gitweb: https://git.kernel.org/tip/888d249117876239593fe3039b6ead8ad6849035 Author: Jarkko Sakkinen <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:23 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Wed, 18 Nov 2020 18:02:49 +01:00
x86/sgx: Add SGX_IOC_ENCLAVE_CREATE
Add an ioctl() that performs the ECREATE function of the ENCLS instruction, which creates an SGX Enclave Control Structure (SECS).
Although the SECS is an in-memory data structure, it is present in enclave memory and is not directly accessible by software.
--- Documentation/userspace-api/ioctl/ioctl-number.rst | 1 +- arch/x86/include/uapi/asm/sgx.h | 25 ++- arch/x86/kernel/cpu/sgx/Makefile | 1 +- arch/x86/kernel/cpu/sgx/driver.c | 12 +- arch/x86/kernel/cpu/sgx/driver.h | 3 +- arch/x86/kernel/cpu/sgx/encl.c | 8 +- arch/x86/kernel/cpu/sgx/encl.h | 7 +- arch/x86/kernel/cpu/sgx/ioctl.c | 123 ++++++++++++- 8 files changed, 180 insertions(+) create mode 100644 arch/x86/include/uapi/asm/sgx.h create mode 100644 arch/x86/kernel/cpu/sgx/ioctl.c
Documentation/userspace-api/ioctl/ioctl-number.rst +1 -0
@@ -323,6 +323,7 @@ Code Seq# Include File Comments <mailto:[email protected]> 0xA3 90-9F linux/dtlk.h 0xA4 00-1F uapi/linux/tee.h Generic TEE subsystem +0xA4 00-1F uapi/asm/sgx.h <mailto:[email protected]> 0xAA 00-3F linux/uapi/linux/userfaultfd.h 0xAB 00-1F linux/nbd.h 0xAC 00-1F linux/raw.h
arch/x86/include/uapi/asm/sgx.h new file +25 -0
@@ -0,0 +1,25 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +/* +* Copyright(c) 2016-20 Intel Corporation. +*/ +#ifndef _UAPI_ASM_X86_SGX_H +#define _UAPI_ASM_X86_SGX_H + +#include <linux/types.h> +#include <linux/ioctl.h> + +#define SGX_MAGIC 0xA4 + +#define SGX_IOC_ENCLAVE_CREATE \ + _IOW(SGX_MAGIC, 0x00, struct sgx_enclave_create) + +/** +* struct sgx_enclave_create - parameter structure for the +* %SGX_IOC_ENCLAVE_CREATE ioctl +* @src: address for the SECS page data +*/ +struct sgx_enclave_create { +__u64 src; +}; + +#endif /* _UAPI_ASM_X86_SGX_H */
arch/x86/kernel/cpu/sgx/Makefile +1 -0
@@ -1,4 +1,5 @@ obj-y += \ driver.o \ encl.o \ + ioctl.o \ main.o
arch/x86/kernel/cpu/sgx/driver.c +12 -0
@@ -88,10 +88,22 @@ static unsigned long sgx_get_unmapped_area(struct file *file,return current->mm->get_unmapped_area (file, addr, len, pgoff, flags); } +#ifdef CONFIG_COMPAT +static long sgx_compat_ioctl (struct file *filep,unsigned int cmd, +unsigned long arg) +{ +return sgx_ioctl (filep, cmd, arg); +} +#endif +static const struct file_operations sgx_encl_fops = { .owner =THIS_MODULE , .open = sgx_open, .release = sgx_release, + .unlocked_ioctl = sgx_ioctl, +#ifdef CONFIG_COMPAT + .compat_ioctl = sgx_compat_ioctl, +#endif .mmap = sgx_mmap, .get_unmapped_area = sgx_get_unmapped_area, };
arch/x86/kernel/cpu/sgx/driver.h +3 -0
@@ -9,8 +9,11 @@#include <linux/rwsem.h> #include <linux/sched.h> #include <linux/workqueue.h> +#include <uapi/asm/sgx.h> #include "sgx.h" +long sgx_ioctl (struct file *filep,unsigned int cmd,unsigned long arg); +int sgx_drv_init (void );#endif /* __ARCH_X86_SGX_DRIVER_H__ */
arch/x86/kernel/cpu/sgx/encl.c +8 -0
@@ -46,6 +46,7 @@ static vm_fault_t sgx_vma_fault(struct vm_fault *vmf)struct sgx_encl_page *entry;unsigned long phys_addr;struct sgx_encl *encl; +unsigned long pfn;vm_fault_t ret; encl = vma->vm_private_data;
@@ -61,6 +62,13 @@ static vm_fault_t sgx_vma_fault(struct vm_fault *vmf) phys_addr =sgx_get_epc_phys_addr (entry->epc_page); +/* Check if another thread got here first to insert the PTE. */ +if (!follow_pfn (vma, addr, &pfn)) { +mutex_unlock (&encl->lock); + +return VM_FAULT_NOPAGE ; + } + ret =vmf_insert_pfn (vma, addr,PFN_DOWN (phys_addr));if (ret !=VM_FAULT_NOPAGE ) {mutex_unlock (&encl->lock);
arch/x86/kernel/cpu/sgx/encl.h +7 -0
@@ -26,9 +26,16 @@ struct sgx_encl_page {struct sgx_encl *encl; }; +enum sgx_encl_flags { +SGX_ENCL_IOCTL =BIT (0 ), +SGX_ENCL_DEBUG =BIT (1 ), +SGX_ENCL_CREATED =BIT (2 ), +}; +struct sgx_encl {unsigned long base;unsigned long size; +unsigned long flags;unsigned int page_cnt;unsigned int secs_child_cnt;struct mutex lock;
arch/x86/kernel/cpu/sgx/ioctl.c new file +123 -0
123 lines not on this page · raw message
[tip: x86/sgx] x86/sgx: Add SGX_IOC_ENCLAVE_INIT
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 9d0c151b41fed7b879030f4e533143d098781701 Gitweb: https://git.kernel.org/tip/9d0c151b41fed7b879030f4e533143d098781701 Author: Jarkko Sakkinen <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:25 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Wed, 18 Nov 2020 18:02:49 +01:00
x86/sgx: Add SGX_IOC_ENCLAVE_INIT
Enclaves have two basic states. They are either being built and are malleable and can be modified by doing things like adding pages. Or, they are locked down and not accepting changes. They can only be run after they have been locked down. The ENCLS[EINIT] function induces the transition from being malleable to locked-down.
Add an ioctl() that performs ENCLS[EINIT]. After this, new pages can no longer be added with ENCLS[EADD]. This is also the time where the enclave can be measured to verify its integrity.
--- arch/x86/include/uapi/asm/sgx.h | 11 ++- arch/x86/kernel/cpu/sgx/driver.c | 27 ++++- arch/x86/kernel/cpu/sgx/driver.h | 8 +- arch/x86/kernel/cpu/sgx/encl.h | 3 +- arch/x86/kernel/cpu/sgx/ioctl.c | 193 +++++++++++++++++++++++++++++- 5 files changed, 241 insertions(+), 1 deletion(-)
arch/x86/include/uapi/asm/sgx.h +11 -0
@@ -23,6 +23,8 @@ enum sgx_page_flags { _IOW(SGX_MAGIC, 0x00, struct sgx_enclave_create)#define SGX_IOC_ENCLAVE_ADD_PAGES \ _IOWR(SGX_MAGIC, 0x01, struct sgx_enclave_add_pages) +#define SGX_IOC_ENCLAVE_INIT \ + _IOW(SGX_MAGIC, 0x02, struct sgx_enclave_init)/** * struct sgx_enclave_create - parameter structure for the
@@ -52,4 +54,13 @@ struct sgx_enclave_add_pages { __u64 count; }; +/** +* struct sgx_enclave_init - parameter structure for the +* %SGX_IOC_ENCLAVE_INIT ioctl +* @sigstruct: address for the SIGSTRUCT data +*/ +struct sgx_enclave_init { +__u64 sigstruct; +}; +#endif /* _UAPI_ASM_X86_SGX_H */
arch/x86/kernel/cpu/sgx/driver.c +27 -0
@@ -10,6 +10,10 @@#include "driver.h" #include "encl.h" +u64 sgx_attributes_reserved_mask; +u64 sgx_xfrm_reserved_mask = ~0x3 ; +u32 sgx_misc_reserved_mask; +static int sgx_open (struct inode *inode,struct file *file) {struct sgx_encl *encl;
@@ -117,8 +121,31 @@ static struct miscdevice sgx_dev_enclave = {int __init sgx_drv_init (void ) { +unsigned int eax, ebx, ecx, edx; +u64 attr_mask; +u64 xfrm_mask; +if (!cpu_feature_enabled (X86_FEATURE_SGX_LC ))return -ENODEV ; +cpuid_count (SGX_CPUID ,0 , &eax, &ebx, &ecx, &edx); + +if (!(eax &1 )) { +pr_err ("SGX disabled: SGX1 instruction support not available.\n" ); +return -ENODEV ; + } + + sgx_misc_reserved_mask = ~ebx |SGX_MISC_RESERVED_MASK ; + +cpuid_count (SGX_CPUID ,1 , &eax, &ebx, &ecx, &edx); + + attr_mask = (((u64 )ebx) <<32 ) + (u64 )eax; + sgx_attributes_reserved_mask = ~attr_mask |SGX_ATTR_RESERVED_MASK ; + +if (cpu_feature_enabled (X86_FEATURE_OSXSAVE )) { + xfrm_mask = (((u64 )edx) <<32 ) + (u64 )ecx; + sgx_xfrm_reserved_mask = ~xfrm_mask; + } +return misc_register (&sgx_dev_enclave); }
arch/x86/kernel/cpu/sgx/driver.h +8 -0
@@ -12,6 +12,14 @@#include <uapi/asm/sgx.h> #include "sgx.h" +#define SGX_EINIT_SPIN_COUNT 20 +#define SGX_EINIT_SLEEP_COUNT 50 +#define SGX_EINIT_SLEEP_TIME 20 + +extern u64 sgx_attributes_reserved_mask; +extern u64 sgx_xfrm_reserved_mask; +extern u32 sgx_misc_reserved_mask; +long sgx_ioctl (struct file *filep,unsigned int cmd,unsigned long arg);int sgx_drv_init (void );
arch/x86/kernel/cpu/sgx/encl.h +3 -0
@@ -30,6 +30,7 @@ enum sgx_encl_flags {SGX_ENCL_IOCTL =BIT (0 ),SGX_ENCL_DEBUG =BIT (1 ),SGX_ENCL_CREATED =BIT (2 ), + SGX_ENCL_INITIALIZED = BIT(3), }; struct sgx_encl {
@@ -41,6 +42,8 @@ struct sgx_encl {struct mutex lock;struct xarray page_array;struct sgx_encl_page secs; +unsigned long attributes; +unsigned long attributes_mask; };extern const struct vm_operations_struct sgx_vm_ops;
arch/x86/kernel/cpu/sgx/ioctl.c +192 -1
217 lines not on this page · raw message
[tip: x86/sgx] x86/sgx: Add SGX_IOC_ENCLAVE_PROVISION
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: c82c61865024b9981f00358433bebed92ca20c00 Gitweb: https://git.kernel.org/tip/c82c61865024b9981f00358433bebed92ca20c00 Author: Jarkko Sakkinen <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:26 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Wed, 18 Nov 2020 18:02:50 +01:00
x86/sgx: Add SGX_IOC_ENCLAVE_PROVISION
The whole point of SGX is to create a hardware protected place to do “stuff”. But, before someone is willing to hand over the keys to the castle , an enclave must often prove that it is running on an SGX-protected processor. Provisioning enclaves play a key role in providing proof.
There are actually three different enclaves in play in order to make this happen:
1. The application enclave. The familiar one we know and love that runs the actual code that’s doing real work. There can be many of these on a single system, or even in a single application.
2. The quoting enclave (QE). The QE is mentioned in lots of silly whitepapers, but, for the purposes of kernel enabling, just pretend they do not exist.
3. The provisioning enclave. There is typically only one of these enclaves per system. Provisioning enclaves have access to a special hardware key.
They can use this key to help to generate certificates which serve as proof that enclaves are running on trusted SGX hardware. These certificates can be passed around without revealing the special key.
Any user who can create a provisioning enclave can access the processor-unique Provisioning Certificate Key which has privacy and fingerprinting implications. Even if a user is permitted to create normal application enclaves (via /dev/sgx_enclave), they should not be able to create provisioning enclaves. That means a separate permissions scheme is needed to control provisioning enclave privileges.
Implement a separate device file (/dev/sgx_provision) which allows creating provisioning enclaves. This device will typically have more strict permissions than the plain enclave device.
The actual device “driver” is an empty stub. Open file descriptors for this device will represent a token which allows provisioning enclave duty. This file descriptor can be passed around and ultimately given as an argument to the /dev/sgx_enclave driver ioctl().
[ bp: Touchups. ]
--- arch/x86/include/uapi/asm/sgx.h | 11 +++++++++- arch/x86/kernel/cpu/sgx/driver.c | 24 +++++++++++++++++++- arch/x86/kernel/cpu/sgx/driver.h | 2 ++- arch/x86/kernel/cpu/sgx/ioctl.c | 37 +++++++++++++++++++++++++++++++- 4 files changed, 73 insertions(+), 1 deletion(-)
arch/x86/include/uapi/asm/sgx.h +11 -0
@@ -25,6 +25,8 @@ enum sgx_page_flags { _IOWR(SGX_MAGIC, 0x01, struct sgx_enclave_add_pages)#define SGX_IOC_ENCLAVE_INIT \ _IOW(SGX_MAGIC, 0x02, struct sgx_enclave_init) +#define SGX_IOC_ENCLAVE_PROVISION \ + _IOW(SGX_MAGIC, 0x03, struct sgx_enclave_provision)/** * struct sgx_enclave_create - parameter structure for the
@@ -63,4 +65,13 @@ struct sgx_enclave_init { __u64 sigstruct; }; +/** +* struct sgx_enclave_provision - parameter structure for the +* %SGX_IOC_ENCLAVE_PROVISION ioctl +* @fd: file handle of /dev/sgx_provision +*/ +struct sgx_enclave_provision { +__u64 fd; +}; +#endif /* _UAPI_ASM_X86_SGX_H */
arch/x86/kernel/cpu/sgx/driver.c +23 -1
@@ -112,6 +112,10 @@ static const struct file_operations sgx_encl_fops = { .get_unmapped_area = sgx_get_unmapped_area, }; +const struct file_operations sgx_provision_fops = { + .owner =THIS_MODULE , +}; +static struct miscdevice sgx_dev_enclave = { .minor =MISC_DYNAMIC_MINOR , .name ="sgx_enclave" ,
@@ -119,11 +123,19 @@ static struct miscdevice sgx_dev_enclave = { .fops = &sgx_encl_fops, }; +static struct miscdevice sgx_dev_provision = { + .minor =MISC_DYNAMIC_MINOR , + .name ="sgx_provision" , + .nodename ="sgx_provision" , + .fops = &sgx_provision_fops, +}; +int __init sgx_drv_init (void ) {unsigned int eax, ebx, ecx, edx;u64 attr_mask;u64 xfrm_mask; +int ret;if (!cpu_feature_enabled (X86_FEATURE_SGX_LC ))return -ENODEV ;
@@ -147,5 +159,15 @@ int __init sgx_drv_init(void) sgx_xfrm_reserved_mask = ~xfrm_mask; } -return misc_register (&sgx_dev_enclave); + ret =misc_register (&sgx_dev_enclave); +if (ret) +return ret; + + ret =misc_register (&sgx_dev_provision); +if (ret) { +misc_deregister (&sgx_dev_enclave); +return ret; + } + +return 0 ; }
arch/x86/kernel/cpu/sgx/driver.h +2 -0
@@ -20,6 +20,8 @@ extern u64 sgx_attributes_reserved_mask;extern u64 sgx_xfrm_reserved_mask;extern u32 sgx_misc_reserved_mask; +extern const struct file_operations sgx_provision_fops; +long sgx_ioctl (struct file *filep,unsigned int cmd,unsigned long arg);int sgx_drv_init (void );
arch/x86/kernel/cpu/sgx/ioctl.c +37 -0
@@ -569,6 +569,40 @@ out:return ret; } +/** +* sgx_ioc_enclave_provision() - handler for %SGX_IOC_ENCLAVE_PROVISION +* @enclave: an enclave pointer +* @arg: userspace pointer to a struct sgx_enclave_provision instance +* +* Allow ATTRIBUTE.PROVISION_KEY for an enclave by providing a file handle to +* /dev/sgx_provision. +* +* Return: +* - 0: Success. +* - -errno: Otherwise. +*/ +static long sgx_ioc_enclave_provision (struct sgx_encl *encl,void __user *arg) +{ +struct sgx_enclave_provision params; +struct file *file; + +if (copy_from_user (¶ms, arg,sizeof (params))) +return -EFAULT ; + + file =fget (params.fd); +if (!file) +return -EINVAL ; + +if (file->f_op != &sgx_provision_fops) { +fput (file); +return -EINVAL ; + } + + encl->attributes_mask |=SGX_ATTR_PROVISIONKEY ; + +fput (file); +return 0 ; +}long sgx_ioctl (struct file *filep,unsigned int cmd,unsigned long arg) {
@@ -588,6 +622,9 @@ long sgx_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)case SGX_IOC_ENCLAVE_INIT : ret =sgx_ioc_enclave_init (encl, (void __user *)arg);break ; +case SGX_IOC_ENCLAVE_PROVISION : + ret =sgx_ioc_enclave_provision (encl, (void __user *)arg); +break ;default : ret = -ENOIOCTLCMD ;break ;
[tip: x86/sgx] x86/sgx: Add SGX_IOC_ENCLAVE_ADD_PAGES
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: c6d26d370767fa227fc44b98a8bdad112efdf563 Gitweb: https://git.kernel.org/tip/c6d26d370767fa227fc44b98a8bdad112efdf563 Author: Jarkko Sakkinen <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:24 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Wed, 18 Nov 2020 18:02:49 +01:00
x86/sgx: Add SGX_IOC_ENCLAVE_ADD_PAGES
SGX enclave pages are inaccessible to normal software. They must be populated with data by copying from normal memory with the help of the EADD and EEXTEND functions of the ENCLS instruction.
Add an ioctl() which performs EADD that adds new data to an enclave, and optionally EEXTEND functions that hash the page contents and use the hash as part of enclave “measurement” to ensure enclave integrity.
The enclave author gets to decide which pages will be included in the enclave measurement with EEXTEND. Measurement is very slow and has sometimes has very little value. For instance, an enclave _could_ measure every page of data and code, but would be slow to initialize. Or, it might just measure its code and then trust that code to initialize the bulk of its data after it starts running.
--- arch/x86/include/uapi/asm/sgx.h | 30 +++- arch/x86/kernel/cpu/sgx/ioctl.c | 284 +++++++++++++++++++++++++++++++- arch/x86/kernel/cpu/sgx/sgx.h | 1 +- 3 files changed, 315 insertions(+)
arch/x86/include/uapi/asm/sgx.h +30 -0
@@ -8,10 +8,21 @@#include <linux/types.h> #include <linux/ioctl.h> +/** +* enum sgx_epage_flags - page control flags +* %SGX_PAGE_MEASURE: Measure the page contents with a sequence of +* ENCLS[EEXTEND] operations. +*/ +enum sgx_page_flags { +SGX_PAGE_MEASURE =0x01 , +}; +#define SGX_MAGIC 0xA4#define SGX_IOC_ENCLAVE_CREATE \ _IOW(SGX_MAGIC, 0x00, struct sgx_enclave_create) +#define SGX_IOC_ENCLAVE_ADD_PAGES \ + _IOWR(SGX_MAGIC, 0x01, struct sgx_enclave_add_pages)/** * struct sgx_enclave_create - parameter structure for the
@@ -22,4 +33,23 @@ struct sgx_enclave_create { __u64 src; }; +/** +* struct sgx_enclave_add_pages - parameter structure for the +* %SGX_IOC_ENCLAVE_ADD_PAGE ioctl +* @src: start address for the page data +* @offset: starting page offset +* @length: length of the data (multiple of the page size) +* @secinfo: address for the SECINFO data +* @flags: page control flags +* @count: number of bytes added (multiple of the page size) +*/ +struct sgx_enclave_add_pages { +__u64 src; +__u64 offset; +__u64 length; +__u64 secinfo; +__u64 flags; +__u64 count; +}; +#endif /* _UAPI_ASM_X86_SGX_H */
arch/x86/kernel/cpu/sgx/ioctl.c +284 -0
296 lines not on this page · raw message
arch/x86/kernel/cpu/sgx/sgx.h +1 -0
@@ -14,6 +14,7 @@#define pr_fmt (fmt) "sgx: " fmt#define SGX_MAX_EPC_SECTIONS 8 +#define SGX_EEXTEND_BLOCK_SIZE 256struct sgx_epc_page {unsigned int section;
[tip: x86/sgx] x86/vdso: Add support for exception fixup in vDSO functions
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 8382c668ce4f367d902f4a340a1bfa9e46096ec1 Gitweb: https://git.kernel.org/tip/8382c668ce4f367d902f4a340a1bfa9e46096ec1 Author: Sean Christopherson <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:27 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Wed, 18 Nov 2020 18:02:50 +01:00
x86/vdso: Add support for exception fixup in vDSO functions
Signals are a horrid little mechanism. They are especially nasty in multi-threaded environments because signal state like handlers is global across the entire process. But, signals are basically the only way that userspace can “gracefully” handle and recover from exceptions.
The kernel generally does not like exceptions to occur during execution. But, exceptions are a fact of life and must be handled in some circumstances. The kernel handles them by keeping a list of individual instructions which may cause exceptions. Instead of truly handling the exception and returning to the instruction that caused it, the kernel instead restarts execution at a *different* instruction. This makes it obvious to that thread of execution that the exception occurred and lets *that* code handle the exception instead of the handler.
This is not dissimilar to the try/catch exceptions mechanisms that some programming languages have, but applied *very* surgically to single instructions. It effectively changes the visible architecture of the instruction.
Problem
=======
SGX generates a lot of signals, and the code to enter and exit enclaves and muck with signal handling is truly horrid. At the same time, an approach like kernel exception fixup can not be easily applied to userspace instructions because it changes the visible instruction architecture.
Solution
========
The vDSO is a special page of kernel-provided instructions that run in userspace. Any userspace calling into the vDSO knows that it is special. This allows the kernel a place to legitimately rewrite the user/kernel contract and change instruction behavior.
Add support for fixing up exceptions that occur while executing in the vDSO. This replaces what could traditionally only be done with signal handling.
This new mechanism will be used to replace previously direct use of SGX instructions by userspace.
Just introduce the vDSO infrastructure. Later patches will actually replace signal generation with vDSO exception fixup.
--- arch/x86/entry/vdso/Makefile | 6 +-- arch/x86/entry/vdso/extable.c | 46 ++++++++++++++++++++++++- arch/x86/entry/vdso/extable.h | 28 +++++++++++++++- arch/x86/entry/vdso/vdso-layout.lds.S | 9 ++++- arch/x86/entry/vdso/vdso2c.h | 50 +++++++++++++++++++++++++- arch/x86/include/asm/vdso.h | 5 +++- 6 files changed, 139 insertions(+), 5 deletions(-) create mode 100644 arch/x86/entry/vdso/extable.c create mode 100644 arch/x86/entry/vdso/extable.h
arch/x86/entry/vdso/Makefile +3 -3
@@ -29,7 +29,7 @@ vobjs32-y := vdso32/note.o vdso32/system_call.o vdso32/sigreturn.o vobjs32-y += vdso32/vclock_gettime.o # files to link into kernel -obj-y += vma.o +obj-y += vma.o extable.o KASAN_SANITIZE_vma.o := y UBSAN_SANITIZE_vma.o := y KCSAN_SANITIZE_vma.o := y
@@ -128,8 +128,8 @@ $(obj)/%-x32.o: $(obj)/%.o FORCE targets += vdsox32.lds $(vobjx32s-y) -$(obj)/%.so: OBJCOPYFLAGS := -S -$(obj)/%.so: $(obj)/%.so.dbg FORCE +$(obj)/%.so: OBJCOPYFLAGS := -S --remove-section __ex_table +$(obj)/%.so: $(obj)/%.so.dbg $(call if_changed,objcopy) $(obj)/vdsox32.so.dbg: $(obj)/vdsox32.lds $(vobjx32s) FORCE
arch/x86/entry/vdso/extable.c new file +46 -0
46 lines not on this page · raw message
arch/x86/entry/vdso/extable.h new file +28 -0
@@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __VDSO_EXTABLE_H +#define __VDSO_EXTABLE_H + +/* +* Inject exception fixup for vDSO code. Unlike normal exception fixup, +* vDSO uses a dedicated handler the addresses are relative to the overall +* exception table, not each individual entry. +*/ +#ifdef __ASSEMBLY__ +#define _ASM_VDSO_EXTABLE_HANDLE (from, to) \ + ASM_VDSO_EXTABLE_HANDLE from to + +.macro ASM_VDSO_EXTABLE_HANDLE from:req to:req + .pushsection __ex_table, "a" + .long (\from) - __ex_table + .long (\to) - __ex_table + .popsection +.endm +#else +#define _ASM_VDSO_EXTABLE_HANDLE (from, to) \ + ".pushsection __ex_table, \"a\"\n" \ + ".long (" #from ") - __ex_table\n" \ + ".long (" #to ") - __ex_table\n" \ + ".popsection\n" +#endif + +#endif /* __VDSO_EXTABLE_H */
arch/x86/entry/vdso/vdso-layout.lds.S +8 -1
@@ -75,11 +75,18 @@ SECTIONS * stuff that isn't used at runtime in between. */ - .text : { *(.text*) } :text =0x90909090, + .text : { + *(.text*) + *(.fixup) + } :text =0x90909090, + + .altinstructions : { *(.altinstructions) } :text .altinstr_replacement : { *(.altinstr_replacement) } :text + __ex_table : { *(__ex_table) } :text + /DISCARD/ : { *(.discard) *(.discard.*)
arch/x86/entry/vdso/vdso2c.h +49 -1
80 lines not on this page · raw message
arch/x86/include/asm/vdso.h +5 -0
@@ -15,6 +15,8 @@ struct vdso_image {unsigned long size;/* Always a multiple of PAGE_SIZE */ unsigned long alt, alt_len; +unsigned long extable_base, extable_len; +const void *extable;long sym_vvar_start;/* Negative offset to the vvar area */
@@ -45,6 +47,9 @@ extern void __init init_vdso_image(const struct vdso_image *image);extern int map_vdso_once (const struct vdso_image *image,unsigned long addr); +extern bool fixup_vdso_exception (struct pt_regs *regs,int trapnr, +unsigned long error_code, +unsigned long fault_addr);#endif /* __ASSEMBLER__ */ #endif /* _ASM_X86_VDSO_H */
[tip: x86/sgx] x86/vdso: Implement a vDSO for Intel SGX enclave call
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 84664369520170f48546c55cbc1f3fbde9b1e140 Gitweb: https://git.kernel.org/tip/84664369520170f48546c55cbc1f3fbde9b1e140 Author: Sean Christopherson <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:30 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Wed, 18 Nov 2020 18:02:50 +01:00
x86/vdso: Implement a vDSO for Intel SGX enclave call
Enclaves encounter exceptions for lots of reasons: everything from enclave page faults to NULL pointer dereferences, to system calls that must be “proxied” to the kernel from outside the enclave.
In addition to the code contained inside an enclave, there is also supporting code outside the enclave called an “SGX runtime”, which is virtually always implemented inside a shared library. The runtime helps build the enclave and handles things like *re*building the enclave if it got destroyed by something like a suspend/resume cycle.
The rebuilding has traditionally been handled in SIGSEGV handlers, registered by the library. But, being process-wide, shared state, signal handling and shared libraries do not mix well.
Introduce a vDSO function call that wraps the enclave entry functions (EENTER/ERESUME functions of the ENCLU instruciton) and returns information about any exceptions to the caller in the SGX runtime.
Instead of generating a signal, the kernel places exception information in RDI, RSI and RDX. The kernel-provided userspace portion of the vDSO handler will place this information in a user-provided buffer or trigger a user-provided callback at the time of the exception.
The vDSO function calling convention uses the standard RDI RSI, RDX, RCX, R8 and R9 registers. This makes it possible to declare the vDSO as a C prototype, but other than that there is no specific support for SystemV ABI. Things like storing XSAVE are the responsibility of the enclave and the runtime.
[ bp: Change vsgx.o build dependency to CONFIG_X86_SGX. ]
--- arch/x86/entry/vdso/Makefile | 2 +- arch/x86/entry/vdso/vdso.lds.S | 1 +- arch/x86/entry/vdso/vsgx.S | 151 +++++++++++++++++++++++++++++++- arch/x86/include/asm/enclu.h | 9 ++- arch/x86/include/uapi/asm/sgx.h | 91 +++++++++++++++++++- 5 files changed, 254 insertions(+) create mode 100644 arch/x86/entry/vdso/vsgx.S create mode 100644 arch/x86/include/asm/enclu.h
arch/x86/entry/vdso/Makefile +2 -0
@@ -27,6 +27,7 @@ VDSO32-$(CONFIG_IA32_EMULATION) := y vobjs-y := vdso-note.o vclock_gettime.o vgetcpu.o vobjs32-y := vdso32/note.o vdso32/system_call.o vdso32/sigreturn.o vobjs32-y += vdso32/vclock_gettime.o +vobjs-$(CONFIG_X86_SGX) += vsgx.o # files to link into kernel obj-y += vma.o extable.o
@@ -98,6 +99,7 @@ $(vobjs): KBUILD_CFLAGS := $(filter-out $(GCC_PLUGINS_CFLAGS) $(RETPOLINE_CFLAGS CFLAGS_REMOVE_vclock_gettime.o = -pg CFLAGS_REMOVE_vdso32/vclock_gettime.o = -pg CFLAGS_REMOVE_vgetcpu.o = -pg +CFLAGS_REMOVE_vsgx.o = -pg # # X32 processes use x32 vDSO to access 64bit kernel data.
arch/x86/entry/vdso/vdso.lds.S +1 -0
@@ -27,6 +27,7 @@ VERSION { __vdso_time; clock_getres; __vdso_clock_getres; + __vdso_sgx_enter_enclave; local: *; }; }
arch/x86/entry/vdso/vsgx.S new file +151 -0
151 lines not on this page · raw message
arch/x86/include/asm/enclu.h new file +9 -0
@@ -0,0 +1,9 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _ASM_X86_ENCLU_H +#define _ASM_X86_ENCLU_H + +#define EENTER 0x02 +#define ERESUME 0x03 +#define EEXIT 0x04 + +#endif /* _ASM_X86_ENCLU_H */
arch/x86/include/uapi/asm/sgx.h +91 -0
95 lines not on this page · raw message
[tip: x86/sgx] x86/sgx: Add ptrace() support for the SGX driver
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 947c6e11fa4310b31c10016ae9816cdca3f1694e Gitweb: https://git.kernel.org/tip/947c6e11fa4310b31c10016ae9816cdca3f1694e Author: Jarkko Sakkinen <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:33 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Wed, 18 Nov 2020 18:04:11 +01:00
x86/sgx: Add ptrace() support for the SGX driver
Enclave memory is normally inaccessible from outside the enclave. This makes enclaves hard to debug. However, enclaves can be put in a debug mode when they are being built. In that mode, enclave data *can* be read and/or written by using the ENCLS[EDBGRD] and ENCLS[EDBGWR] functions.
This is obviously only for debugging and destroys all the protections present with normal enclaves. But, enclaves know their own debug status and can adjust their behavior appropriately.
Add a vm_ops->access() implementation which can be used to read and write memory inside debug enclaves. This is typically used via ptrace() APIs.
[ bp: Massage. ]
--- arch/x86/kernel/cpu/sgx/encl.c | 111 ++++++++++++++++++++++++++++++++- 1 file changed, 111 insertions(+)
arch/x86/kernel/cpu/sgx/encl.c +111 -0
@@ -272,10 +272,121 @@ static int sgx_vma_mprotect(struct vm_area_struct *vma, unsigned long start,return sgx_encl_may_map (vma->vm_private_data, start, end, newflags); } +static int sgx_encl_debug_read (struct sgx_encl *encl,struct sgx_encl_page *page, +unsigned long addr,void *data) +{ +unsigned long offset = addr & ~PAGE_MASK ; +int ret; + + + ret =__edbgrd (sgx_get_epc_virt_addr (page->epc_page) + offset, data); +if (ret) +return -EIO ; + +return 0 ; +} + +static int sgx_encl_debug_write (struct sgx_encl *encl,struct sgx_encl_page *page, +unsigned long addr,void *data) +{ +unsigned long offset = addr & ~PAGE_MASK ; +int ret; + + ret =__edbgwr (sgx_get_epc_virt_addr (page->epc_page) + offset, data); +if (ret) +return -EIO ; + +return 0 ; +} + +/* +* Load an enclave page to EPC if required, and take encl->lock. +*/ +static struct sgx_encl_page *sgx_encl_reserve_page (struct sgx_encl *encl, +unsigned long addr, +unsigned long vm_flags) +{ +struct sgx_encl_page *entry; + +for ( ; ; ) { +mutex_lock (&encl->lock); + + entry =sgx_encl_load_page (encl, addr, vm_flags); +if (PTR_ERR (entry) != -EBUSY ) +break ; + +mutex_unlock (&encl->lock); + } + +if (IS_ERR (entry)) +mutex_unlock (&encl->lock); + +return entry; +} + +static int sgx_vma_access (struct vm_area_struct *vma,unsigned long addr, +void *buf,int len,int write) +{ +struct sgx_encl *encl = vma->vm_private_data; +struct sgx_encl_page *entry =NULL ; +char data[sizeof (unsigned long )]; +unsigned long align; +int offset; +int cnt; +int ret =0 ; +int i; + +/* +* If process was forked, VMA is still there but vm_private_data is set +* to NULL. +*/ +if (!encl) +return -EFAULT ; + +if (!test_bit (SGX_ENCL_DEBUG , &encl->flags)) +return -EFAULT ; + +for (i =0 ; i < len; i += cnt) { + entry =sgx_encl_reserve_page (encl, (addr + i) &PAGE_MASK , + vma->vm_flags); +if (IS_ERR (entry)) { + ret =PTR_ERR (entry); +break ; + } + + align =ALIGN_DOWN (addr + i,sizeof (unsigned long )); + offset = (addr + i) & (sizeof (unsigned long ) -1 ); + cnt =sizeof (unsigned long ) - offset; + cnt =min (cnt, len - i); + + ret =sgx_encl_debug_read (encl, entry, align, data); +if (ret) + goto out; + +if (write) { +memcpy (data + offset, buf + i, cnt); + ret =sgx_encl_debug_write (encl, entry, align, data); +if (ret) + goto out; + }else { +memcpy (buf + i, data + offset, cnt); + } + +out: +mutex_unlock (&encl->lock); + +if (ret) +break ; + } + +return ret <0 ? ret : i; +} +const struct vm_operations_struct sgx_vm_ops = { .fault = sgx_vma_fault, .mprotect = sgx_vma_mprotect, .open = sgx_vma_open, + .access = sgx_vma_access, };/**
[tip: x86/sgx] Documentation/x86: Document SGX kernel architecture
In reply to Jarkko SakkinenThe following commit has been merged into the x86/sgx branch of tip:
The following commit has been merged into the x86/sgx branch of tip:
Commit-ID: 3fa97bf001262a1d88ec9b4ac5ae6abe0ed1356c Gitweb: https://git.kernel.org/tip/3fa97bf001262a1d88ec9b4ac5ae6abe0ed1356c Author: Jarkko Sakkinen <[email protected]> AuthorDate: Fri, 13 Nov 2020 00:01:34 +02:00 Committer: Borislav Petkov <[email protected]> CommitterDate: Wed, 18 Nov 2020 18:16:13 +01:00
Documentation/x86: Document SGX kernel architecture
Document the Intel SGX kernel architecture. The fine-grained architecture details can be looked up from Intel SDM Volume 3D.
--- Documentation/x86/index.rst | 1 +- Documentation/x86/sgx.rst | 211 +++++++++++++++++++++++++++++++++++- 2 files changed, 212 insertions(+) create mode 100644 Documentation/x86/sgx.rst
Documentation/x86/index.rst +1 -0
@@ -33,3 +33,4 @@ x86-specific Documentation i386/index x86_64/index sva + sgx
Documentation/x86/sgx.rst new file +211 -0
211 lines not on this page · raw message
Quoted 63 lines · Jarkko Sakkinen
Overview
========Intel(R) SGX is new hardware functionality that can be used by applications to populate protected regions of user code and data called enclaves. Once activated, the new hardware protects enclave code and data from outside access and modification.
SGX implementations have existed on desktop processors for several years. The upcoming 3rd Generation Intel Xeon Scalable Platform, code-named ???Ice Lake??? will also support SGX[1].
Use Cases
=========Enclaves provide a place to store secrets and process data with those secrets. SGX has been used, for example, to decrypt video without exposing the decryption keys to nosy debuggers that might be used to subvert DRM. Software has generally been rewritten specifically to run in enclaves, but there are also projects that try to run limited unmodified software in enclaves[2].
SGX hardware is available in public clouds today. But, anyone wishing to use it must use a modified distribution or side-load SGX support[3].
Hardware Implementation
=======================New memory controller hardware encrypts data transparently before leaving the processor package. The randomly-generated encryption key has a lifetime of exactly one power cycle. This mitigates attacks originating outside the processor, like snooping DIMM traffic.
Important Kernel Touch Points
=============================Although statically carved out of normal DRAM, enclave memory can not be accessed or managed directly by the kernel and is marked by the firmware as ???Reserved???. As a result, SGX support contains simple but analogous functionality to the core mm such as a page allocator and reclaim.
Entering and exiting enclaves is tricky business. Enclaves are restricted from making system calls or taking interrupts directly. The enclave will exit out to userspace before things like this can happen. A new vDSO exception mechanism is introduced to help smooth over some of the architectural rough edges and make the job of userspace easier.
This implementation is picky and will decline to work on hardware which is locked to Intel???s root of trust.
1. https://newsroom.intel.com/news-releases/intel-xeon-scalable-platform-built-most-sensitive-workloads/
2. https://grapheneproject.io/
3. https://docs.microsoft.com/en-us/azure/confidential-computing/quick-create-portalOther
=====Sean Christopherson is a major contributor to this series. However, he has left Intel and his @intel.com address will soon be bouncing. He does not have a email he wants us to substitute or put in .mailmap for now. To avoid subjecting everyone to bounces, we have commented out his tag lines in the commit messages.
Quoted 4 lines
Originally the code was based on early prototyping work of Suresh S.
This patch set has been rebased on top of tip tree commit
c3c30db1b191bb1640a08bbcc593c212affcab75.
Occlum project (https://occlum.io/) is a libOS built on top of Intel SGX feature. We ran Occlum tests using v5.10 kernel with SGX patch v41 on SGX hardware with the Flexible Launch Control (FLC) feature and didn't find any problems. As Occlum core developers, we would like these patches to be merged.
Quoted 751 lines
v40 (2020-10-20):
* Change copyright years to 2016-2020 in the all files added.
https://lore.kernel.org/linux-sgx/[email protected]/
* Remove dual licensing and use GPL 2.0 unconditionally.
https://lore.kernel.org/linux-sgx/[email protected]/
* Remove platform capabilities checks fromsgx_validate_secs(), as they are validated together with the SIGSTRUCT capabilities insgx_ioc_enclave_init().
https://lore.kernel.org/linux-sgx/[email protected]/
* During the migration fromradix_treeto xarray, the locks went missing fromsgx_encl_may_map(). Fix this by iterating with the enclave lock and xarray lock held.
https://lore.kernel.org/linux-sgx/[email protected]/
* Verify in the #PF handler that the faulted page has equal or higher build time permissions than the VMA permissions (i.e. the subset of {VM_READ,VM_WRITE,VM_EXECUTE} invma->vm_flags). Trigger a bus error, if this not the case. By doing this,mmap()andmprotect()can be allowed to map an address range, which has unpopulated pages, because the required invariant will be checked before new pages are inserted to the process address space.
* In the vDSO, do not save RBX before validating the reserved area of the structsgx_enclave_run.
https://lore.kernel.org/linux-sgx/[email protected]/
* Increase the reserved area to 256 bytes in structsgx_enclave_runas there needs to be some space for expansion given the evolution of microarchitectures, the fact that there can be only one vDSO and possible future extensions.
https://lore.kernel.org/linux-sgx/[email protected]/
* Change Copyright comments from '//' to '/* ... */'.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix the error fallback path in the SGX vDSO. RAX was not popped in the error path.
https://lore.kernel.org/linux-sgx/[email protected]/
* Move mm list management, backing storage and refcounting code to ???x86/sgx: Add a page reclaimer???, as they are only needed by the page reclaimer. Finally, change the patch position to be the very last after the kselftest, so that the whole patch set can be tested easily with and without the reclaimer.
* Movesgx_xsave_size_tblcode from ???x86/sgx: Add SGX enclave driver??? to ???x86/sgx: AddSGX_IOC_ENCLAVE_CREATE???. Comment the code and useXFEATURE_YMMandXFEATURE_MAXas limits for the features.
* Fix bugsgx_sanitize_section()that pages left dirty were not returned back, which could lead to a memory leak. Renameunsanitized_page_listas more intuitive and shorterlaundry_listand document the function itself and the call site.
* Usevmalloc()to allocate an array of struct sgx_epc_page???s for structsgx_epc_section, in effect removing the need to store addresses inside the page structures. This removes the artificial limit of 8 sections. The section array is still statically allocated but now it is trivial to increase its size later on.
* Rest of the changes are documented in patch change logs as this is preferred way for the x86 tree.v39 (2020-10-03):
* A new GIT tree location.
git://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-sgx.git
* Return-ERESTARTSYSinstead of-EINTRinSGX_IOC_ENCLAVE_ADD_PAGES.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Do not initialize 'encl_size' insgx_encl_createbefore
sgx_validate_secs()is called.
https://lore.kernel.org/linux-sgx/[email protected]/
* Revert 'count' back to structsgx_enclave_add_pages, move the check of
-EIOtosgx_ioc_enclave_pages()instead of being buried in subfunctions.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix documentation for the 'encl' parameter insgx_ioc_enclave_create(),
sgx_ioc_enclave_init()andsgx_ioc_enclave_provision().
https://lore.kernel.org/linux-sgx/[email protected]/
* Refinesgx_ioc_enclave_create()kdoc to better describe the meaning and
purpose of SECS validation done bysgx_validate_secs().
https://lore.kernel.org/linux-sgx/[email protected]/
* Improve documentationsgx_ioc_enclave_add_pages()on IO failures.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix a bug in__sgx_encl_add_page(). Whenget_user_pages()fails, we must
return-EFAULTinstead of mistakenly returning the page count.
Reported by Haitao Huang.
* Rewrite the commit message forvm_ops->mprotect()(courtesy of Dave Hansen)
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix ptrace support coding style issues.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix the documentation.
https://lore.kernel.org/linux-sgx/[email protected]/
* Always write MSRs for the public key before EINIT.
https://lore.kernel.org/linux-sgx/[email protected]/
* Categorically disabled enclaves from noexec partitions.
https://lore.kernel.org/linux-sgx/[email protected]/
* Properly document the EWB flow, i.e. why there is three trials for EWB.
https://lore.kernel.org/linux-sgx/[email protected]/
* Add kdoc about batch processing tosgx_reclaim_pages().
https://lore.kernel.org/linux-sgx/[email protected]/
https://lore.kernel.org/linux-mm/[email protected]/
* Documentation fixes.
https://lore.kernel.org/linux-sgx/[email protected]/T/#me637011aba9f45698eba88ff195452c0491c07fe
* SGX vDSO clean ups.
https://lore.kernel.org/linux-sgx/[email protected]/T/#ma2204bba8d8e8a09bf9164fc1bb5c55813997b4a
* Add the commit message from "x86/vdso: Add support for exception fixup in vDSO functions" toDocumentation/x86/sgx.rst
https://lore.kernel.org/linux-sgx/[email protected]/
* Update correct attributes variable when allowing provisioning.
https://lore.kernel.org/linux-sgx/[email protected]/T/#t
* Removesgx_exceptionand put its fields tosgx_exception.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Remove 'exit_reason' and put EEXIT to 'self' field ofsgx_enclave_run.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Refine clarity of the field names in structsgx_enclave_runandvsgx.S, and rewrite kdoc.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Fix memory validation invsgx.S. The reserved areas was not zero validated,
which causes unnecessary risk for memory corruption bugs. In effect, 'flags'
field can be removed from structsgx_enclave_run.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Reduce the size ofsgx_enclave_runfrom 256 bytes to 64 bytes, i.e. size of
a cache line. This leave 24 bytes of free space to waste in future.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Verify atttributes, miscsselect and xfrm also in EINIT against SIGSTRUCT set
limits.
https://lore.kernel.org/linux-sgx/[email protected]/
* Use plain lfence instead of retpoline in the vDSO because retpoline has
the potential to cause forward compatibility issues with the future
microarchitecture features. One such in already sight is CET-SS.
https://lore.kernel.org/linux-sgx/[email protected]/T/#ma65748158e2b967dbc1d9ac3b214a1415066d61cv38:
* Fast iteration because I had email server issues with v37. Using temporary SMTP for this (mail.kapsi.fi).
* Return-EINTRwhen no data is processed, just likeread().
https://patchwork.kernel.org/patch/11773941/
* Remove cruft fromSGX_IOC_ENCLAVE_ADD_PAGESand fix the return value.
https://lore.kernel.org/linux-sgx/[email protected]/T/#mc643ef2ab477f5f7aa5d463d883d1308eb44d6f1v37:
* Remove MODULE_*().
https://lore.kernel.org/linux-sgx/[email protected]/
* Fixmmap()type check.
https://lore.kernel.org/linux-sgx/20200827152051.GB22351@sjchrist-ice/
* Fix ioctl-number.txt.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix SPDX identifier inarch/x86/include/uapi/asm/sgx.h
https://lore.kernel.org/linux-sgx/[email protected]/
* Consistently document "@encl: an enclave pointer".
https://lore.kernel.org/linux-sgx/[email protected]/
* RenamedSGX_IOC_ENCLAVE_SET_ATTRIBUTEasSGX_IOC_ENCLAVE_PROVISIONand
cleaned up associated code. Also fixed issues of code introduced too
early that were caused by the split. Now it should be more streamlined.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fixed signed integer shift overflow:
https://github.com/intel/linux-sgx-driver/pull/16/commitsd27ca6071b2b28e2e789d265eda796dd9fc65a64
* Fixed off-by-one error in a size calculation:
https://github.com/intel/SGXDataCenterAttestationPrimitives/commit/e44cc238becf584cc079aef40b557c6af9a03f38
* Rework vDSO API with a context structure for IO data.
https://lore.kernel.org/linux-sgx/[email protected]/
* Refined commentary about retry-loop with ENCLS[EINIT] based on Sean's response.
https://lore.kernel.org/linux-sgx/[email protected]/
* Return positive number fromSGX_IOC_ENCLAVE_ADD_PAGESindicating the
number of pages processed and set a fixed 1MB limit for length. In addition,
on interrupt, return 0 and number of processed pages instead of-EINTR.
https://lore.kernel.org/linux-sgx/[email protected]/v36:
* Make a self-containedmprotect()handler.
* Move fromradix_treeto xarray, which is more modern and robust data structure for managing large sparse arrays. Renameencl->page_treeasencl->page_array.v35:
* Add missingSGX_ENCL_DEADcheck tosgx_ioctl().v34:
* RemoveSGX_ENCL_DEADchecks fromioctl.c, as the file is open while executing an ioctl.
* Split driver patch into base patch and one patch for each ioctl.
* Moveencl->flagscheck to the beginning of each ioctl. Return consistently-EINVALif they don't match the expected values. Before, sometimes-EFAULTwas returned instead of-EINVAL.
* Renamevm_ops->may_mprotectasvm_ops->mprotect()and move the call right before call tomprotect_fixup().v33:
* Rebased to v5.8-rc1. Given the core changes (mmap_lockand #DB handling), it made sense to update the series.
* Refined documentation about how remote attestation is done in SGX.v32:
* v31 contained not fully cleaned upmain.cafter merger ofmain.candreclaim.c. Fixed in this version.
* Rebased to v5.7. Forgot to do this for v31.v31:
* UnsetSGX_ENCL_IOCTLin the error path of checkingencl->flagsin order to prevent leaving it set and thus block any further ioctl calls.
* Added missingcleanup_srcu_struct()call tosgx_encl_release().
* Takeencl->lockinsgx_encl_add_page()in order to prevent races with the page reclaimer.
* Fix a use-after-free bug from the page reclaimer. Callkref_put()forencl->refcountonly after putting enclave page back to the active page list because it could be the last ref to the enclave.
* Filter any CPU disallowed values fromsigstruct->vendorSGX_IOC_ENCLAVE_INIT.
* Use bits 0-7 of page descriptor for the EPC section index. This should be enough for long term needs.
* Refined naming for functions that allocate and free EPC pages to be more sound and consistent.
* Mergemain.candreclaim.cinto one.v30:
Bunch of tags added. No actual code changes.v29:
* The selftest has been moved to selftests/sgx. Because SGX is an execution environment of its own, it really isn't a great fit with more "standard" x86 tests.The RSA key is now generated on fly and the whole signing process has been made as part of the enclave loader instead of signing the enclave during the compilation time.
Finally, the enclave loader loads now the test enclave directly from its ELF file, which means that ELF file does not need to be coverted as raw binary during the build process.
* Version themm_listinstead of using onsynchronize_mm()when adding new entries. We hold the write lock for themm_struct, anddup_mm()can thus deadlock with the page reclaimer, which could hold the lock for the oldmm_struct.
* Disallowmmap(PROT_NONE)from/dev/sgx. Any mapping (e.g. anonymous) can be used to reserve the address range. Now/dev/sgxsupports only opaque mappings to the (initialized) enclave data.
* Make the vDSO callable directly from C by preserving RBX and taking leaf from RCX.v28:
* Documented toDocumentation/x86/sgx.rsthow the kernel manages the enclave ownership.
* Removed non-LC flow fromsgx_einit().
* Removed structsgx_einittokensince only the size of the corresponding microarchitectural structure is used in the series ATM.v27:
* Disallow RIE processes to use enclaves as there could a permission conflict between VMA and enclave permissions.
* In the documentation, replace "grep/proc/cpuinfo" with "grep sgx/proc/cpuinfo".v26:
* Fixed the commit author in "x86/sgx: Linux Enclave Driver", which was changed in v25 by mistake.
* Addressed a bunch of grammar mistakes insgx.rst(thanks Randy once again for such a detailed feedback).
* Added back theMAINTAINERSupdate commit, which was mistakenly removed in v25.
* EREMOVE's for SECS cannot be done while sanitizing an EPC section. The CPU does not allow to remove a SECS page before all of its children have been removed, and a child page can be in some other section than the one currently being processed. Thus, removed special SECS processing fromsgx_sanitize_page()and instead put sections through it twice. In the 2nd round the lists should only contain SECS pages.v25:
* Fix a double-free issue whenSGX_IOC_ENCLAVE_ADD_PAGES
fails on executing ENCLS[EADD]. The rollback path executedradix_tree_delete()on the same address twice when this happened.
* Return-EINTRinstead of-ERESTARTSYSinSGX_IOC_ENCLAVE_ADD_PAGESwhen a signal is pending.
* As requested by Borislav, move the CPUID0x12features to their own word in cpufeatures.
* Sean fixed a bug fromsgx_reclaimer_write()wheresgx_encl_put_backing()was called with an uninitialized pointer whensgx_encl_get_backing()fails.
* Migrated/dev/sgx/*to misc. This is future-proof as struct miscdevice has 'groups' for setting up sysfs attributes for the device.
* Usedevice_initcallinstead ofsubsys_initcallso thatmisc_classis initialized before SGX is initialized.
* Return-EACCESinSGX_IOC_ENCLAVE_INITwhen caller tries to select enclave attributes that we the kernel does not allow it to set instead of-EINVAL.
* Unless SGX public key MSRs are writable always deny the feature from Linux. Previously this was only denied from driver. How VMs should be supported is not really part of initial patch set, which makes this an obvious choice.
* Cleaned up and refined documentation to be more approachable.v24:
* Reclaim unmeasured and TCS pages (regression in v23).
* Replace usages ofGFP_HIGHUSERwithGFP_KERNEL.
* Return-EIOon when EADD or EEXTEND fails in %SGX_IOC_ENCLAVE_ADD_PAGES and use the same rollback (destroy enclave). This can happen when host suspends itself unknowingly to a VM running enclaves. From-EIOthe user space can deduce what happened.
* Have a separate @count in structsgx_enclave_add_pagesto output number of bytes processed instead of overwriting the input parameters for clarity and more importantly that the API provides means for partial processing (@count could be less than @length in success case).v23:
* ReplaceSGX_ENCLAVE_ADD_PAGEwithSGX_ENCLAVE_ADD_PAGES. Replace @mrmask with %SGX_PAGE_MEASURE flag.
* Return-EIOinstead of-ECANCELEDwhenptrace()fails to read a TCS page.
* In the reclaimer, pin page before ENCLS[EBLOCK] because pinning can fail (because of OOM) even in legit behaviour and after EBLOCK the reclaiming flow can be only reverted by killing the whole enclave.
* FixedSGX_ATTR_RESERVED_MASK. Bit 7 was marked as reserved while in fact it should have been bit 6 (Table 37-3 in the SDM).
* Return-EPERMfromSGX_IOC_ENCLAVE_INITwhen ENCLS[EINIT] returns an SGX error code.v22:
* Refined bunch commit messages and added associated SDM references as many of them were too exhausting and some outdated.
* Alignment checks have been removed frommmap()because it does not define the ELRANGE. VMAs only act as windows to the enclave. The semantics compare somewhat howmmap()works with regular files.
* We now require user space addresses given toSGX_IOC_ENCLAVE_ADD_PAGEto be page aligned so that we can pass the page directly to EADD and do not have to do an extra copy. This was made effectively possible by removing the worker thread for adding pages.
* The selftest build files have been refined throughout of various glitches and work properly in a cross compilation environment such as BuildRoot. In addition, libcalls fail the build with an assertion in the linker script, if they end up to the enclave binary.
*CONFIG_INTEL_SGX_DRIVERhas been removed because you cannot use SGX core for anything without having the driver. This could change when KVM support is added.
* We require zero permissions in SECINFO for TCS pages because the CPU overwrites SECINFO flags with zero permissions and measures the page only after that. Allowing to pass TCS with non-zero permissions would cause mismatching measurement between the one provided in SIGSTRUCT and the one computed by the CPU.
* Obviously lots of small fixes and clean ups (does make sense to document them all).v21:
* Check onmmap()that the VMA does cover an area that does not have enclave pages. Only mapping withPROT_NONEcan do that to reserve initial address space for an enclave.
* Check ommmap()andmprotect()that the VMA permissions do not surpass the enclave permissions.
* Remove two refcounts fromvma_close():mm_listandencl->refcount. Enclave refcount is only need for swapper/enclave sync and we can removemm_listrefcount by destroyingmm_structwhen the process is closed. By not havingvm_close()the Linux MM can merge VMAs.
* Do not naturally alignMAP_FIXEDaddress.
* Numerous small fixes and clean ups.
* Use SRCU for synchronizing the list of mm_struct's.
* Move to stack based call convention in the vDSO.v20:
* Fine-tuneKconfigmessages and spacing and removeMMU_NOTIFIERdependency as MMU notifiers are no longer used in the driver.
* Usemm_usersinstead ofmm_countas refcount formm_structasmm_countonly protects from deletingmm_struct, not removing its contents.
* Sanitize EPC when the reclaimer thread starts by doing EREMOVE for all of them. They could be in initialized state when the kernel starts because it might be spawned bykexec().
* Documentation overhaul.
* Use a device/dev/sgx/provisionfor delivering the provision token instead of securityfs.
* Create a reference to the enclave when already when opening/dev/sgx/enclave. The file is then associated with this enclave only.mmap()can be done at free at any point and always get a reference to the enclave. To summarize the file now represents the enclave.v19:
* Took 3-4 months but in some sense this was more like a rewrite of most of the corners of the source code. If I've forgotten to deal with some feedback, please don't shout me. Make a remark and I will fix it for the next version. Hopefully there won't be this big turnovers anymore.
* Validate SECS attributes properly against CPUID given attributes and against allowed attributes. SECS attributes are the ones that are enforced whereas SIGSTRUCT attributes tell what is required to run the enclave.
* Add KSS (Key Sharing Support) to the enclave attributes.
* DenyMAP_PRIVATEas an enclave is always a shared memory entity.
* Revert back to shmem backing storage so that it can be easily shared by multiple processes.
* Split the recognization of an ENCLS leaf failure by using three functions to detect it:encsl_faulted(),encls_returned_code()andsgx_failed().encls_failed()is only caused by a spurious expections that should never happen. Thus, it is not defined as an inline function in order to easily insert a kprobe to it.
* Move low-level enclave management routines, page fault handler and page reclaiming routines from driver to the core. These cannot be separated from each other as they are heavily interdependent. The rationale is that the core does not call any code from the driver.
* Allow the driver to be compiled as a module now that it no code is using its routines and it only uses exported symbols. Now the driver is essentially just a thin ioctl layer.
* Reworked the driver to maintain a list of mm_struct's. The VMA callbacks add new entries to this list as the process is forked. Each entry has its own refcount because they have a different life-cycle as the enclave does. In effect @tgid and @mm have been removed from structsgx_encland we allow forking by removingVM_DONTCOPYfrom vm flags.
* Generate a cpu mask in the reclaimer from the cpu mask's of all mm_struct's. This will kick out the hardware threads out of the enclave from multiple processes. It is not a local variable because it would eat too much of the stack space but instead a field in structsgx_encl.
* Allow forking i.e. removeVM_DONTCOPY. I did not change the API because the old API scaled to the workload that Andy described. The codebase is now mostly API independent i.e. changing the API is a small task. For me the proper trigger to chanage it is a as concrete as possible workload that cannot be fulfilled. I hope you understand my thinking here. I don't want to change anything w/o proper basis but I'm ready to change anything if there is a proper basis. I do not have any kind of attachment to any particular type of API.
* Add Sean's vDSO ENCLS(EENTER) patches and update selftest to use the new vDSO.v18:
* Update the ioctl-number.txt.
* Move the driver underarch/x86.
* Add SGX features (SGX, SGX1, SGX2) to thedisabled-features.h.
* Rename the selftest astest_sgx(previously sgx-selftest).
* In order to enable process accounting, swap EPC pages and PCMD's to a VMA instead of shmem.
* Allow only to initialize and run enclaves with a subset of {DEBUG, MODE64BIT} set.
* AddSGX_IOC_ENCLAVE_SET_ATTRIBUTEto allow an enclave to have privileged attributes e.g. PROVISIONKEY.v17:
* Add a simple selftest.
* Fix a null pointer dereference tosection->pageswhen its allocation fails.
* Add Sean's description of the exception handling to the documentation.v16:
* Fixed SOB's in the commits that were a bit corrupted in v15.
* Implemented exceptio handling properly todetect_sgx().
* UseGENMASK()to defineSGX_CPUID_SUB_LEAF_TYPE_MASK.
* Updated the documentation to use rst definition lists.
* Added the missingDocumentation/x86/index.rst, which has a link tointel_sgx.rst. Now the SGX and uapi documentation is properly generated with 'make htmldocs'.
* While enumerating EPC sections, if an undefined section is found, fail the driver initialization instead of continuing the initialization.
* Issue a warning if there are more than %SGX_MAX_EPC_SECTIONS.
* Remove copyright notice fromarch/x86/include/asm/sgx.h.
* Migrated fromioremap_cache()tomemremap().v15:
* Split into more digestable size patches.
* Lots of small fixes and clean ups.
* Signal a "plain" SIGSEGV on an EPCM violation.v14:
* Change the comment aboutX86_FEATURE_SGX_LCfrom ???SGX launch configuration??? to ???SGX launch control???.
* Move the SGX-related CPU feature flags as part of the Linux defined virtual leaf 8.
* AddSGX_prefix to the constants defining the ENCLS leaf functions.
* Use GENMASK*() and BIT*() insgx_arch.hinstead of raw hex numbers.
* Refine the long description forCONFIG_INTEL_SGX_CORE.
* Do not use pr_*_ratelimited() in the driver. The use of the rate limited versions is legacy cruft from the prototyping phase.
* Detect sleep withSGX_INVALID_EINIT_TOKENinstead of counting power cycles.
* Manually prefix with ???sgx:??? in the core SGX code instead of redefiningpr_fmt.
* Report ifIA32_SGXLEPUBKEYHASHxMSRs are not writable in the driver instead of core because it is a driver requirement.
* Change prompt to bool in the entry forCONFIG_INTEL_SGX_COREbecause the default is ???n???.
* Rename structsgx_epc_bankas structsgx_epc_sectionin order to match the SDM.
* Allocate structsgx_epc_pageinstances one at a time.
* Use ???__iomem void *??? pointers for the mapped EPC memory consistently.
* Retry once onSGX_INVALID_TOKENinsgx_einit()instead of counting power cycles.
* Call enclave swapping operations directly from the driver instead of calling them .indirectly through structsgx_epc_page_opsbecause indirect calls are not required yet as the patch set does not contain the KVM support.
* Added special signalSEGV_SGXERRto notify about SGX EPCM violation errors.v13:
* Always useSGX_CPUIDconstant instead of a hardcoded value.
* Simplified and documented the macros and functions for ENCLS leaves.
* Enablesgx_free_page()to free active enclave pages on demand in order to allowsgx_invalidate()to delete enclave pages. It no longer performs EREMOVE if a page is in the process of being reclaimed.
* Use PM notifier per enclave so that we don't have to traverse the global list of active EPC pages to find enclaves.
* Removed unusedSGX_LE_ROLLBACKconstant fromuapi/asm/sgx.h
* Always useioremap()to map EPC banks as we only support 64-bit kernel.
* InvalidateIA32_SGXLEPUBKEYHASHcache used bysgx_einit()when going to sleep.v12:
* Split to more narrow scoped commits in order to ease the review process and use co-developed-by tag for co-authors of commits instead of listing them in the source files.
* Removed cruftEXPORT_SYMBOL()declarations and converted to static variables.
* Removed in-kernel LE i.e. this version of the SGX software stack only supports unlockedIA32_SGXLEPUBKEYHASHxMSRs.
* Refined documentation on launching enclaves, swapping and enclave construction.
* Refinedsgx_arch.hto include alignment information for every struct that requires it and removed structs that are not needed without an LE.
* Got rid ofSGX_CPUID.
* SGX detection now prints log messages about firmware configuration issues.v11:
* Polished ENCLS wrappers with refined exception handling.
* ksgxswapd was not stopped (regression in v5) insgx_page_cache_teardown(), which causes a leaked kthread after driver deinitialization.
* Shutdownsgx_le_proxywhen going to suspend because its EPC pages will be invalidated when resuming, which will cause it not function properly anymore.
* Set EINITTOKEN.VALID to zero for a token that is passed when SGXLEPUBKEYHASH matches MRSIGNER asalloc_page()does not give a zero page.
* Fixed the check insgx_edbgrd()for a TCS page. Allowed to read offsets around the flags field, which causes a #GP. Only flags read is readable.
* On read accessmemcpy()call insidesgx_vma_access()had src and dest parameters in wrong order.
* The build issue withCONFIG_KASANis now fixed. Added undefined symbols to LE even if ???KASAN_SANITIZE := false??? was set in the makefile.
* Fixed a regression in the #PF handler. If a page hasSGX_ENCL_PAGE_RESERVEDflag the #PF handler should unconditionally fail. It did not, which caused weird races when trying to change other parts of swapping code.
* EPC management has been refactored to a flat LRU cache and moved toarch/x86. The swapper thread reads a cluster of EPC pages and swaps all of them. It can now swap from multiple enclaves in the same round.
* For the sake of consistency withSGX_IOC_ENCLAVE_ADD_PAGE, return-EINVALwhen an enclave is already initialized or dead instead of zero.v10:
* Cleaned up anon inode based IPC between the ring-0 and ring-3 parts of the driver.
* Unset the reserved flag from an enclave page if EDBGRD/WR fails (regression in v6).
* Close the anon inode when LE is stopped (regression in v9).
* Update the documentation with a more detailed description of SGX.v9:
* Replaced kernel-LE IPC based on pipes with an anonymous inode. The driver does not require anymore new exports.v8:
* Check that public key MSRs match the LE public key hash in the driver initialization when the MSRs are read-only.
* Fix the race in VA slot allocation by checking the fullness immediately after succeesful allocation.
* Fix the race in hash mrsigner calculation between the launch enclave and user enclaves by having a separate lock for hash calculation.v7:
* Fixed offset calculation in sgx_edbgr/wr(). Address was masked withPAGE_MASKwhen it should have been masked with ~PAGE_MASK.
* Fixed a memory leak insgx_ioc_enclave_create().
* Simplified swapping code by using a pointer array for a cluster instead of a linked list.
* Squeezed structsgx_encl_pageto 32 bytes.
* Fixed deferencing of an RSA key on OpenSSL 1.1.0.
* Modified TC's CMAC to use kernel AES-NI. Restructured the code
a bit in order to better align with kernel conventions.v6:
* Fixed semaphore underrun when accessing/dev/sgxfrom the launch enclave.
* Insgx_encl_create()s/IS_ERR(secs)/IS_ERR(encl)/.
* Removed virtualization chapter from the documentation.
* Changed the default filename for the signing key as signing_key.pem.
* Reworked EPC management in a way that instead of a linked list of structsgx_epc_pageinstances there is an array of integers that encodes address and bank of an EPC page (the same data as 'pa' field earlier). The locking has been moved to the EPC bank level instead of a global lock.
* Relaxed locking requirements for EPC management. EPC pages can be released back to the EPC bank concurrently.
* Cleaned upptrace()code.
* Refined commit messages for new architectural constants.
* Sorted includes in every source file.
* Sorted local variable declarations according to the line length in every function.
* Style fixes based on Darren's comments tosgx_le.c.v5:
* Described IPC between the Launch Enclave and kernel in the commit messages.
* Fixed all relevant checkpatch.pl issues that I have forgot fix in earlier versions except those that exist in the imported TinyCrypt code.
* Fixed spelling mistakes in the documentation.
* Forgot to check the return value ofsgx_drv_subsys_init().
* Encapsulated properly page cache init and teardown.
* Collect epc pages to a temp list insgx_add_epc_bank
* RemovedSGX_ENCLAVE_INIT_ARCHconstant.v4:
* Tied life-cycle of thesgx_le_proxyprocess to/dev/sgx.
* Removed__exitannotation fromsgx_drv_subsys_exit().
* Fixed a leak of a backing page insgx_process_add_page_req()in the case whenvm_insert_pfn()fails.
* Removed unused symbol exports forsgx_page_cache.c.
* Updatedsgx_alloc_page()to require encl parameter and documented the behavior (Sean Christopherson).
* Refactored a more lean API forsgx_encl_find()and documented the behavior.
* Moved #PF handler tosgx_fault.c.
* Replacedsubsys_system_register()with plainbus_register().
* Retry EINIT 2nd time only if MSRs are not locked.v3:
* Check thatFEATURE_CONTROL_LOCKEDandFEATURE_CONTROL_SGX_ENABLEare set.
* Return-ERESTARTSYSin__sgx_encl_add_page()whensgx_alloc_page()fails.
* Use unused bits inepc_page->pato store the bank number.
* Removed #ifdef forWQ_NONREENTRANT.
* Ifmmu_notifier_register()fails with-EINTR, return-ERESTARTSYS.
* Added --remove-section=.got.plt to objcopy flags in order to prevent a dummy .got.plt, which will cause an inconsistent size for the LE.
* Documented sgx_encl_* functions.
* Added remark about AES implementation used inside the LE.
* Removed redundantsgx_sys_exit()fromle/main.c.
* Fixed structsgx_secinfoalignment from 128 to 64 bytes.
* Validate miscselect insgx_encl_create().
* Fixed SSA frame size calculation to take the misc region into account.
* Implemented consistent exception handling to__encls()and__encls_ret().
* Implemented a proper device model in order to allow sysfs attributes and in-kernel API.
* Cleaned up various "find enclave" implementations to the unifiedsgx_encl_find().
* Validate thatvm_pgoffis zero.
* Discard backing pages withshmem_truncate_range()after EADD.
* Added missing EEXTEND operations to LE signing and launch.
* Fixed SSA size for GPRS region from 168 to 184 bytes.
* Fixed the checks for TCS flags. Now DBGOPTIN is allowed.
* Check that TCS addresses are in ELRANGE and not just page aligned.
* Require kernel to be compiled withX64_64andCPU_SUP_INTEL.
* Fixed an incorrect value forSGX_ATTR_DEBUGfrom0x01to0x02.v2:
*get_rand_uint32()changed the value of the pointer instead of value where it is pointing at.
* Launch enclave incorrectly used sigstruct attributes-field instead of enclave attributes-field.
* Removed unused structsgx_add_page_reqfromsgx_ioctl.c
* Removed unusedsgx_has_sgx2.
* Updatedarch/x86/include/asm/sgx.hso that it provides stub implementations when sgx in not enabled.
* Removed cruft rdmsr-calls fromsgx_set_pubkeyhash_msrs().
* return-ENOMEMinsgx_alloc_page()when VA pages consume too much space
* removed unused globalsgx_nr_pids
* movedsgx_encl_releasetosgx_encl.c
* return-ERESTARTSYSinstead of-EINTRinsgx_encl_init()Jarkko Sakkinen (14):
x86/sgx: Add SGX architectural data structures x86/sgx: Add wrappers for ENCLS functions x86/cpu/intel: Add nosgx kernel parameter x86/sgx: Add SGX page allocator functions x86/sgx: Add SGX misc driver interface x86/sgx: AddSGX_IOC_ENCLAVE_CREATEx86/sgx: AddSGX_IOC_ENCLAVE_ADD_PAGESx86/sgx: AddSGX_IOC_ENCLAVE_INITx86/sgx: AddSGX_IOC_ENCLAVE_PROVISIONselftests/x86: Add a selftest for SGX x86/sgx: Add a page reclaimer
x86/sgx: Addptrace()support for the SGX driver
docs: x86/sgx: Document SGX kernel architecture x86/sgx: UpdateMAINTAINERSSean Christopherson (10):
x86/cpufeatures: x86/msr: Add Intel SGX hardware bits x86/cpufeatures: x86/msr: Add Intel SGX Launch Control hardware bits x86/sgx: Initialize metadata for Enclave Page Cache (EPC) sections x86/mm: x86/sgx: Signal SIGSEGV withPF_SGXx86/cpu/intel: Detect SGX support
mm: Add 'mprotect' hook to structvm_operations_structx86/vdso: Add support for exception fixup in vDSO functions x86/fault: Add helper function to sanitize error code x86/traps: Attempt to fixup exceptions in vDSO before signaling x86/vdso: Implement a vDSO for Intel SGX enclave call.../admin-guide/kernel-parameters.txt | 2 + .../userspace-api/ioctl/ioctl-number.rst | 1 + Documentation/x86/index.rst | 1 + Documentation/x86/sgx.rst | 211 +++++ MAINTAINERS | 13 + arch/x86/Kconfig | 17 + arch/x86/entry/vdso/Makefile | 8 +- arch/x86/entry/vdso/extable.c | 46 ++ arch/x86/entry/vdso/extable.h | 28 + arch/x86/entry/vdso/vdso-layout.lds.S | 9 +- arch/x86/entry/vdso/vdso.lds.S | 1 + arch/x86/entry/vdso/vdso2c.h | 50 +- arch/x86/entry/vdso/vsgx.S | 151 ++++ arch/x86/include/asm/cpufeatures.h | 2 + arch/x86/include/asm/disabled-features.h | 8 +- arch/x86/include/asm/enclu.h | 9 + arch/x86/include/asm/msr-index.h | 8 + arch/x86/include/asm/trap_pf.h | 1 + arch/x86/include/asm/vdso.h | 5 + arch/x86/include/uapi/asm/sgx.h | 168 ++++ arch/x86/kernel/cpu/Makefile | 1 + arch/x86/kernel/cpu/feat_ctl.c | 38 +- arch/x86/kernel/cpu/sgx/Makefile | 5 + arch/x86/kernel/cpu/sgx/arch.h | 338 ++++++++ arch/x86/kernel/cpu/sgx/driver.c | 194 +++++ arch/x86/kernel/cpu/sgx/driver.h | 29 + arch/x86/kernel/cpu/sgx/encl.c | 740 ++++++++++++++++++ arch/x86/kernel/cpu/sgx/encl.h | 121 +++ arch/x86/kernel/cpu/sgx/encls.h | 231 ++++++ arch/x86/kernel/cpu/sgx/ioctl.c | 716 +++++++++++++++++ arch/x86/kernel/cpu/sgx/main.c | 731 +++++++++++++++++ arch/x86/kernel/cpu/sgx/sgx.h | 77 ++ arch/x86/kernel/traps.c | 10 + arch/x86/mm/fault.c | 45 +- include/linux/mm.h | 7 + mm/mprotect.c | 7 + tools/testing/selftests/Makefile | 1 + tools/testing/selftests/sgx/.gitignore | 2 + tools/testing/selftests/sgx/Makefile | 53 ++ tools/testing/selftests/sgx/call.S | 44 ++ tools/testing/selftests/sgx/defines.h | 21 + tools/testing/selftests/sgx/load.c | 277 +++++++ tools/testing/selftests/sgx/main.c | 246 ++++++ tools/testing/selftests/sgx/main.h | 38 + tools/testing/selftests/sgx/sigstruct.c | 391 +++++++++ tools/testing/selftests/sgx/test_encl.c | 20 + tools/testing/selftests/sgx/test_encl.lds | 40 + .../selftests/sgx/test_encl_bootstrap.S | 89 +++ 48 files changed, 5232 insertions(+), 19 deletions(-) create mode 100644 Documentation/x86/sgx.rst create mode 100644 arch/x86/entry/vdso/extable.c create mode 100644 arch/x86/entry/vdso/extable.h create mode 100644 arch/x86/entry/vdso/vsgx.S create mode 100644 arch/x86/include/asm/enclu.h create mode 100644 arch/x86/include/uapi/asm/sgx.h create mode 100644 arch/x86/kernel/cpu/sgx/Makefile create mode 100644 arch/x86/kernel/cpu/sgx/arch.h create mode 100644 arch/x86/kernel/cpu/sgx/driver.c create mode 100644 arch/x86/kernel/cpu/sgx/driver.h create mode 100644 arch/x86/kernel/cpu/sgx/encl.c create mode 100644 arch/x86/kernel/cpu/sgx/encl.h create mode 100644 arch/x86/kernel/cpu/sgx/encls.h create mode 100644 arch/x86/kernel/cpu/sgx/ioctl.c create mode 100644 arch/x86/kernel/cpu/sgx/main.c create mode 100644 arch/x86/kernel/cpu/sgx/sgx.h create mode 100644 tools/testing/selftests/sgx/.gitignore create mode 100644 tools/testing/selftests/sgx/Makefile create mode 100644 tools/testing/selftests/sgx/call.S create mode 100644 tools/testing/selftests/sgx/defines.h create mode 100644 tools/testing/selftests/sgx/load.c create mode 100644 tools/testing/selftests/sgx/main.c create mode 100644 tools/testing/selftests/sgx/main.h create mode 100644 tools/testing/selftests/sgx/sigstruct.c create mode 100644 tools/testing/selftests/sgx/test_encl.c create mode 100644 tools/testing/selftests/sgx/test_encl.lds create mode 100644 tools/testing/selftests/sgx/test_encl_bootstrap.SSignature · 1 line
2.27.0
Quoted 63 lines · Jarkko Sakkinen
Overview
========Intel(R) SGX is new hardware functionality that can be used by applications to populate protected regions of user code and data called enclaves. Once activated, the new hardware protects enclave code and data from outside access and modification.
SGX implementations have existed on desktop processors for several years. The upcoming 3rd Generation Intel Xeon Scalable Platform, code-named ???Ice Lake??? will also support SGX[1].
Use Cases
=========Enclaves provide a place to store secrets and process data with those secrets. SGX has been used, for example, to decrypt video without exposing the decryption keys to nosy debuggers that might be used to subvert DRM. Software has generally been rewritten specifically to run in enclaves, but there are also projects that try to run limited unmodified software in enclaves[2].
SGX hardware is available in public clouds today. But, anyone wishing to use it must use a modified distribution or side-load SGX support[3].
Hardware Implementation
=======================New memory controller hardware encrypts data transparently before leaving the processor package. The randomly-generated encryption key has a lifetime of exactly one power cycle. This mitigates attacks originating outside the processor, like snooping DIMM traffic.
Important Kernel Touch Points
=============================Although statically carved out of normal DRAM, enclave memory can not be accessed or managed directly by the kernel and is marked by the firmware as ???Reserved???. As a result, SGX support contains simple but analogous functionality to the core mm such as a page allocator and reclaim.
Entering and exiting enclaves is tricky business. Enclaves are restricted from making system calls or taking interrupts directly. The enclave will exit out to userspace before things like this can happen. A new vDSO exception mechanism is introduced to help smooth over some of the architectural rough edges and make the job of userspace easier.
This implementation is picky and will decline to work on hardware which is locked to Intel???s root of trust.
1. https://newsroom.intel.com/news-releases/intel-xeon-scalable-platform-built-most-sensitive-workloads/
2. https://grapheneproject.io/
3. https://docs.microsoft.com/en-us/azure/confidential-computing/quick-create-portalOther
=====Sean Christopherson is a major contributor to this series. However, he has left Intel and his @intel.com address will soon be bouncing. He does not have a email he wants us to substitute or put in .mailmap for now. To avoid subjecting everyone to bounces, we have commented out his tag lines in the commit messages.
Quoted 4 lines
Originally the code was based on early prototyping work of Suresh S.
This patch set has been rebased on top of tip tree commit
c3c30db1b191bb1640a08bbcc593c212affcab75.
The Occlum project (https://occlum.io/) is a libOS built on top of Intel SGX feature. We ran Occlum tests using v5.10 kernel with SGX patch v41 on SGX hardware with the Flexible Launch Control (FLC) feature and didn't find any problems. As Occlum core developers, we would like these patches to be merged.
Quoted 751 lines
v40 (2020-10-20):
* Change copyright years to 2016-2020 in the all files added.
https://lore.kernel.org/linux-sgx/[email protected]/
* Remove dual licensing and use GPL 2.0 unconditionally.
https://lore.kernel.org/linux-sgx/[email protected]/
* Remove platform capabilities checks fromsgx_validate_secs(), as they are validated together with the SIGSTRUCT capabilities insgx_ioc_enclave_init().
https://lore.kernel.org/linux-sgx/[email protected]/
* During the migration fromradix_treeto xarray, the locks went missing fromsgx_encl_may_map(). Fix this by iterating with the enclave lock and xarray lock held.
https://lore.kernel.org/linux-sgx/[email protected]/
* Verify in the #PF handler that the faulted page has equal or higher build time permissions than the VMA permissions (i.e. the subset of {VM_READ,VM_WRITE,VM_EXECUTE} invma->vm_flags). Trigger a bus error, if this not the case. By doing this,mmap()andmprotect()can be allowed to map an address range, which has unpopulated pages, because the required invariant will be checked before new pages are inserted to the process address space.
* In the vDSO, do not save RBX before validating the reserved area of the structsgx_enclave_run.
https://lore.kernel.org/linux-sgx/[email protected]/
* Increase the reserved area to 256 bytes in structsgx_enclave_runas there needs to be some space for expansion given the evolution of microarchitectures, the fact that there can be only one vDSO and possible future extensions.
https://lore.kernel.org/linux-sgx/[email protected]/
* Change Copyright comments from '//' to '/* ... */'.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix the error fallback path in the SGX vDSO. RAX was not popped in the error path.
https://lore.kernel.org/linux-sgx/[email protected]/
* Move mm list management, backing storage and refcounting code to ???x86/sgx: Add a page reclaimer???, as they are only needed by the page reclaimer. Finally, change the patch position to be the very last after the kselftest, so that the whole patch set can be tested easily with and without the reclaimer.
* Movesgx_xsave_size_tblcode from ???x86/sgx: Add SGX enclave driver??? to ???x86/sgx: AddSGX_IOC_ENCLAVE_CREATE???. Comment the code and useXFEATURE_YMMandXFEATURE_MAXas limits for the features.
* Fix bugsgx_sanitize_section()that pages left dirty were not returned back, which could lead to a memory leak. Renameunsanitized_page_listas more intuitive and shorterlaundry_listand document the function itself and the call site.
* Usevmalloc()to allocate an array of struct sgx_epc_page???s for structsgx_epc_section, in effect removing the need to store addresses inside the page structures. This removes the artificial limit of 8 sections. The section array is still statically allocated but now it is trivial to increase its size later on.
* Rest of the changes are documented in patch change logs as this is preferred way for the x86 tree.v39 (2020-10-03):
* A new GIT tree location.
git://git.kernel.org/pub/scm/linux/kernel/git/jarkko/linux-sgx.git
* Return-ERESTARTSYSinstead of-EINTRinSGX_IOC_ENCLAVE_ADD_PAGES.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Do not initialize 'encl_size' insgx_encl_createbefore
sgx_validate_secs()is called.
https://lore.kernel.org/linux-sgx/[email protected]/
* Revert 'count' back to structsgx_enclave_add_pages, move the check of
-EIOtosgx_ioc_enclave_pages()instead of being buried in subfunctions.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix documentation for the 'encl' parameter insgx_ioc_enclave_create(),
sgx_ioc_enclave_init()andsgx_ioc_enclave_provision().
https://lore.kernel.org/linux-sgx/[email protected]/
* Refinesgx_ioc_enclave_create()kdoc to better describe the meaning and
purpose of SECS validation done bysgx_validate_secs().
https://lore.kernel.org/linux-sgx/[email protected]/
* Improve documentationsgx_ioc_enclave_add_pages()on IO failures.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix a bug in__sgx_encl_add_page(). Whenget_user_pages()fails, we must
return-EFAULTinstead of mistakenly returning the page count.
Reported by Haitao Huang.
* Rewrite the commit message forvm_ops->mprotect()(courtesy of Dave Hansen)
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix ptrace support coding style issues.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix the documentation.
https://lore.kernel.org/linux-sgx/[email protected]/
* Always write MSRs for the public key before EINIT.
https://lore.kernel.org/linux-sgx/[email protected]/
* Categorically disabled enclaves from noexec partitions.
https://lore.kernel.org/linux-sgx/[email protected]/
* Properly document the EWB flow, i.e. why there is three trials for EWB.
https://lore.kernel.org/linux-sgx/[email protected]/
* Add kdoc about batch processing tosgx_reclaim_pages().
https://lore.kernel.org/linux-sgx/[email protected]/
https://lore.kernel.org/linux-mm/[email protected]/
* Documentation fixes.
https://lore.kernel.org/linux-sgx/[email protected]/T/#me637011aba9f45698eba88ff195452c0491c07fe
* SGX vDSO clean ups.
https://lore.kernel.org/linux-sgx/[email protected]/T/#ma2204bba8d8e8a09bf9164fc1bb5c55813997b4a
* Add the commit message from "x86/vdso: Add support for exception fixup in vDSO functions" toDocumentation/x86/sgx.rst
https://lore.kernel.org/linux-sgx/[email protected]/
* Update correct attributes variable when allowing provisioning.
https://lore.kernel.org/linux-sgx/[email protected]/T/#t
* Removesgx_exceptionand put its fields tosgx_exception.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Remove 'exit_reason' and put EEXIT to 'self' field ofsgx_enclave_run.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Refine clarity of the field names in structsgx_enclave_runandvsgx.S, and rewrite kdoc.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Fix memory validation invsgx.S. The reserved areas was not zero validated,
which causes unnecessary risk for memory corruption bugs. In effect, 'flags'
field can be removed from structsgx_enclave_run.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Reduce the size ofsgx_enclave_runfrom 256 bytes to 64 bytes, i.e. size of
a cache line. This leave 24 bytes of free space to waste in future.
https://lore.kernel.org/linux-sgx/[email protected]/T/#u
* Verify atttributes, miscsselect and xfrm also in EINIT against SIGSTRUCT set
limits.
https://lore.kernel.org/linux-sgx/[email protected]/
* Use plain lfence instead of retpoline in the vDSO because retpoline has
the potential to cause forward compatibility issues with the future
microarchitecture features. One such in already sight is CET-SS.
https://lore.kernel.org/linux-sgx/[email protected]/T/#ma65748158e2b967dbc1d9ac3b214a1415066d61cv38:
* Fast iteration because I had email server issues with v37. Using temporary SMTP for this (mail.kapsi.fi).
* Return-EINTRwhen no data is processed, just likeread().
https://patchwork.kernel.org/patch/11773941/
* Remove cruft fromSGX_IOC_ENCLAVE_ADD_PAGESand fix the return value.
https://lore.kernel.org/linux-sgx/[email protected]/T/#mc643ef2ab477f5f7aa5d463d883d1308eb44d6f1v37:
* Remove MODULE_*().
https://lore.kernel.org/linux-sgx/[email protected]/
* Fixmmap()type check.
https://lore.kernel.org/linux-sgx/20200827152051.GB22351@sjchrist-ice/
* Fix ioctl-number.txt.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fix SPDX identifier inarch/x86/include/uapi/asm/sgx.h
https://lore.kernel.org/linux-sgx/[email protected]/
* Consistently document "@encl: an enclave pointer".
https://lore.kernel.org/linux-sgx/[email protected]/
* RenamedSGX_IOC_ENCLAVE_SET_ATTRIBUTEasSGX_IOC_ENCLAVE_PROVISIONand
cleaned up associated code. Also fixed issues of code introduced too
early that were caused by the split. Now it should be more streamlined.
https://lore.kernel.org/linux-sgx/[email protected]/
* Fixed signed integer shift overflow:
https://github.com/intel/linux-sgx-driver/pull/16/commitsd27ca6071b2b28e2e789d265eda796dd9fc65a64
* Fixed off-by-one error in a size calculation:
https://github.com/intel/SGXDataCenterAttestationPrimitives/commit/e44cc238becf584cc079aef40b557c6af9a03f38
* Rework vDSO API with a context structure for IO data.
https://lore.kernel.org/linux-sgx/[email protected]/
* Refined commentary about retry-loop with ENCLS[EINIT] based on Sean's response.
https://lore.kernel.org/linux-sgx/[email protected]/
* Return positive number fromSGX_IOC_ENCLAVE_ADD_PAGESindicating the
number of pages processed and set a fixed 1MB limit for length. In addition,
on interrupt, return 0 and number of processed pages instead of-EINTR.
https://lore.kernel.org/linux-sgx/[email protected]/v36:
* Make a self-containedmprotect()handler.
* Move fromradix_treeto xarray, which is more modern and robust data structure for managing large sparse arrays. Renameencl->page_treeasencl->page_array.v35:
* Add missingSGX_ENCL_DEADcheck tosgx_ioctl().v34:
* RemoveSGX_ENCL_DEADchecks fromioctl.c, as the file is open while executing an ioctl.
* Split driver patch into base patch and one patch for each ioctl.
* Moveencl->flagscheck to the beginning of each ioctl. Return consistently-EINVALif they don't match the expected values. Before, sometimes-EFAULTwas returned instead of-EINVAL.
* Renamevm_ops->may_mprotectasvm_ops->mprotect()and move the call right before call tomprotect_fixup().v33:
* Rebased to v5.8-rc1. Given the core changes (mmap_lockand #DB handling), it made sense to update the series.
* Refined documentation about how remote attestation is done in SGX.v32:
* v31 contained not fully cleaned upmain.cafter merger ofmain.candreclaim.c. Fixed in this version.
* Rebased to v5.7. Forgot to do this for v31.v31:
* UnsetSGX_ENCL_IOCTLin the error path of checkingencl->flagsin order to prevent leaving it set and thus block any further ioctl calls.
* Added missingcleanup_srcu_struct()call tosgx_encl_release().
* Takeencl->lockinsgx_encl_add_page()in order to prevent races with the page reclaimer.
* Fix a use-after-free bug from the page reclaimer. Callkref_put()forencl->refcountonly after putting enclave page back to the active page list because it could be the last ref to the enclave.
* Filter any CPU disallowed values fromsigstruct->vendorSGX_IOC_ENCLAVE_INIT.
* Use bits 0-7 of page descriptor for the EPC section index. This should be enough for long term needs.
* Refined naming for functions that allocate and free EPC pages to be more sound and consistent.
* Mergemain.candreclaim.cinto one.v30:
Bunch of tags added. No actual code changes.v29:
* The selftest has been moved to selftests/sgx. Because SGX is an execution environment of its own, it really isn't a great fit with more "standard" x86 tests.The RSA key is now generated on fly and the whole signing process has been made as part of the enclave loader instead of signing the enclave during the compilation time.
Finally, the enclave loader loads now the test enclave directly from its ELF file, which means that ELF file does not need to be coverted as raw binary during the build process.
* Version themm_listinstead of using onsynchronize_mm()when adding new entries. We hold the write lock for themm_struct, anddup_mm()can thus deadlock with the page reclaimer, which could hold the lock for the oldmm_struct.
* Disallowmmap(PROT_NONE)from/dev/sgx. Any mapping (e.g. anonymous) can be used to reserve the address range. Now/dev/sgxsupports only opaque mappings to the (initialized) enclave data.
* Make the vDSO callable directly from C by preserving RBX and taking leaf from RCX.v28:
* Documented toDocumentation/x86/sgx.rsthow the kernel manages the enclave ownership.
* Removed non-LC flow fromsgx_einit().
* Removed structsgx_einittokensince only the size of the corresponding microarchitectural structure is used in the series ATM.v27:
* Disallow RIE processes to use enclaves as there could a permission conflict between VMA and enclave permissions.
* In the documentation, replace "grep/proc/cpuinfo" with "grep sgx/proc/cpuinfo".v26:
* Fixed the commit author in "x86/sgx: Linux Enclave Driver", which was changed in v25 by mistake.
* Addressed a bunch of grammar mistakes insgx.rst(thanks Randy once again for such a detailed feedback).
* Added back theMAINTAINERSupdate commit, which was mistakenly removed in v25.
* EREMOVE's for SECS cannot be done while sanitizing an EPC section. The CPU does not allow to remove a SECS page before all of its children have been removed, and a child page can be in some other section than the one currently being processed. Thus, removed special SECS processing fromsgx_sanitize_page()and instead put sections through it twice. In the 2nd round the lists should only contain SECS pages.v25:
* Fix a double-free issue whenSGX_IOC_ENCLAVE_ADD_PAGES
fails on executing ENCLS[EADD]. The rollback path executedradix_tree_delete()on the same address twice when this happened.
* Return-EINTRinstead of-ERESTARTSYSinSGX_IOC_ENCLAVE_ADD_PAGESwhen a signal is pending.
* As requested by Borislav, move the CPUID0x12features to their own word in cpufeatures.
* Sean fixed a bug fromsgx_reclaimer_write()wheresgx_encl_put_backing()was called with an uninitialized pointer whensgx_encl_get_backing()fails.
* Migrated/dev/sgx/*to misc. This is future-proof as struct miscdevice has 'groups' for setting up sysfs attributes for the device.
* Usedevice_initcallinstead ofsubsys_initcallso thatmisc_classis initialized before SGX is initialized.
* Return-EACCESinSGX_IOC_ENCLAVE_INITwhen caller tries to select enclave attributes that we the kernel does not allow it to set instead of-EINVAL.
* Unless SGX public key MSRs are writable always deny the feature from Linux. Previously this was only denied from driver. How VMs should be supported is not really part of initial patch set, which makes this an obvious choice.
* Cleaned up and refined documentation to be more approachable.v24:
* Reclaim unmeasured and TCS pages (regression in v23).
* Replace usages ofGFP_HIGHUSERwithGFP_KERNEL.
* Return-EIOon when EADD or EEXTEND fails in %SGX_IOC_ENCLAVE_ADD_PAGES and use the same rollback (destroy enclave). This can happen when host suspends itself unknowingly to a VM running enclaves. From-EIOthe user space can deduce what happened.
* Have a separate @count in structsgx_enclave_add_pagesto output number of bytes processed instead of overwriting the input parameters for clarity and more importantly that the API provides means for partial processing (@count could be less than @length in success case).v23:
* ReplaceSGX_ENCLAVE_ADD_PAGEwithSGX_ENCLAVE_ADD_PAGES. Replace @mrmask with %SGX_PAGE_MEASURE flag.
* Return-EIOinstead of-ECANCELEDwhenptrace()fails to read a TCS page.
* In the reclaimer, pin page before ENCLS[EBLOCK] because pinning can fail (because of OOM) even in legit behaviour and after EBLOCK the reclaiming flow can be only reverted by killing the whole enclave.
* FixedSGX_ATTR_RESERVED_MASK. Bit 7 was marked as reserved while in fact it should have been bit 6 (Table 37-3 in the SDM).
* Return-EPERMfromSGX_IOC_ENCLAVE_INITwhen ENCLS[EINIT] returns an SGX error code.v22:
* Refined bunch commit messages and added associated SDM references as many of them were too exhausting and some outdated.
* Alignment checks have been removed frommmap()because it does not define the ELRANGE. VMAs only act as windows to the enclave. The semantics compare somewhat howmmap()works with regular files.
* We now require user space addresses given toSGX_IOC_ENCLAVE_ADD_PAGEto be page aligned so that we can pass the page directly to EADD and do not have to do an extra copy. This was made effectively possible by removing the worker thread for adding pages.
* The selftest build files have been refined throughout of various glitches and work properly in a cross compilation environment such as BuildRoot. In addition, libcalls fail the build with an assertion in the linker script, if they end up to the enclave binary.
*CONFIG_INTEL_SGX_DRIVERhas been removed because you cannot use SGX core for anything without having the driver. This could change when KVM support is added.
* We require zero permissions in SECINFO for TCS pages because the CPU overwrites SECINFO flags with zero permissions and measures the page only after that. Allowing to pass TCS with non-zero permissions would cause mismatching measurement between the one provided in SIGSTRUCT and the one computed by the CPU.
* Obviously lots of small fixes and clean ups (does make sense to document them all).v21:
* Check onmmap()that the VMA does cover an area that does not have enclave pages. Only mapping withPROT_NONEcan do that to reserve initial address space for an enclave.
* Check ommmap()andmprotect()that the VMA permissions do not surpass the enclave permissions.
* Remove two refcounts fromvma_close():mm_listandencl->refcount. Enclave refcount is only need for swapper/enclave sync and we can removemm_listrefcount by destroyingmm_structwhen the process is closed. By not havingvm_close()the Linux MM can merge VMAs.
* Do not naturally alignMAP_FIXEDaddress.
* Numerous small fixes and clean ups.
* Use SRCU for synchronizing the list of mm_struct's.
* Move to stack based call convention in the vDSO.v20:
* Fine-tuneKconfigmessages and spacing and removeMMU_NOTIFIERdependency as MMU notifiers are no longer used in the driver.
* Usemm_usersinstead ofmm_countas refcount formm_structasmm_countonly protects from deletingmm_struct, not removing its contents.
* Sanitize EPC when the reclaimer thread starts by doing EREMOVE for all of them. They could be in initialized state when the kernel starts because it might be spawned bykexec().
* Documentation overhaul.
* Use a device/dev/sgx/provisionfor delivering the provision token instead of securityfs.
* Create a reference to the enclave when already when opening/dev/sgx/enclave. The file is then associated with this enclave only.mmap()can be done at free at any point and always get a reference to the enclave. To summarize the file now represents the enclave.v19:
* Took 3-4 months but in some sense this was more like a rewrite of most of the corners of the source code. If I've forgotten to deal with some feedback, please don't shout me. Make a remark and I will fix it for the next version. Hopefully there won't be this big turnovers anymore.
* Validate SECS attributes properly against CPUID given attributes and against allowed attributes. SECS attributes are the ones that are enforced whereas SIGSTRUCT attributes tell what is required to run the enclave.
* Add KSS (Key Sharing Support) to the enclave attributes.
* DenyMAP_PRIVATEas an enclave is always a shared memory entity.
* Revert back to shmem backing storage so that it can be easily shared by multiple processes.
* Split the recognization of an ENCLS leaf failure by using three functions to detect it:encsl_faulted(),encls_returned_code()andsgx_failed().encls_failed()is only caused by a spurious expections that should never happen. Thus, it is not defined as an inline function in order to easily insert a kprobe to it.
* Move low-level enclave management routines, page fault handler and page reclaiming routines from driver to the core. These cannot be separated from each other as they are heavily interdependent. The rationale is that the core does not call any code from the driver.
* Allow the driver to be compiled as a module now that it no code is using its routines and it only uses exported symbols. Now the driver is essentially just a thin ioctl layer.
* Reworked the driver to maintain a list of mm_struct's. The VMA callbacks add new entries to this list as the process is forked. Each entry has its own refcount because they have a different life-cycle as the enclave does. In effect @tgid and @mm have been removed from structsgx_encland we allow forking by removingVM_DONTCOPYfrom vm flags.
* Generate a cpu mask in the reclaimer from the cpu mask's of all mm_struct's. This will kick out the hardware threads out of the enclave from multiple processes. It is not a local variable because it would eat too much of the stack space but instead a field in structsgx_encl.
* Allow forking i.e. removeVM_DONTCOPY. I did not change the API because the old API scaled to the workload that Andy described. The codebase is now mostly API independent i.e. changing the API is a small task. For me the proper trigger to chanage it is a as concrete as possible workload that cannot be fulfilled. I hope you understand my thinking here. I don't want to change anything w/o proper basis but I'm ready to change anything if there is a proper basis. I do not have any kind of attachment to any particular type of API.
* Add Sean's vDSO ENCLS(EENTER) patches and update selftest to use the new vDSO.v18:
* Update the ioctl-number.txt.
* Move the driver underarch/x86.
* Add SGX features (SGX, SGX1, SGX2) to thedisabled-features.h.
* Rename the selftest astest_sgx(previously sgx-selftest).
* In order to enable process accounting, swap EPC pages and PCMD's to a VMA instead of shmem.
* Allow only to initialize and run enclaves with a subset of {DEBUG, MODE64BIT} set.
* AddSGX_IOC_ENCLAVE_SET_ATTRIBUTEto allow an enclave to have privileged attributes e.g. PROVISIONKEY.v17:
* Add a simple selftest.
* Fix a null pointer dereference tosection->pageswhen its allocation fails.
* Add Sean's description of the exception handling to the documentation.v16:
* Fixed SOB's in the commits that were a bit corrupted in v15.
* Implemented exceptio handling properly todetect_sgx().
* UseGENMASK()to defineSGX_CPUID_SUB_LEAF_TYPE_MASK.
* Updated the documentation to use rst definition lists.
* Added the missingDocumentation/x86/index.rst, which has a link tointel_sgx.rst. Now the SGX and uapi documentation is properly generated with 'make htmldocs'.
* While enumerating EPC sections, if an undefined section is found, fail the driver initialization instead of continuing the initialization.
* Issue a warning if there are more than %SGX_MAX_EPC_SECTIONS.
* Remove copyright notice fromarch/x86/include/asm/sgx.h.
* Migrated fromioremap_cache()tomemremap().v15:
* Split into more digestable size patches.
* Lots of small fixes and clean ups.
* Signal a "plain" SIGSEGV on an EPCM violation.v14:
* Change the comment aboutX86_FEATURE_SGX_LCfrom ???SGX launch configuration??? to ???SGX launch control???.
* Move the SGX-related CPU feature flags as part of the Linux defined virtual leaf 8.
* AddSGX_prefix to the constants defining the ENCLS leaf functions.
* Use GENMASK*() and BIT*() insgx_arch.hinstead of raw hex numbers.
* Refine the long description forCONFIG_INTEL_SGX_CORE.
* Do not use pr_*_ratelimited() in the driver. The use of the rate limited versions is legacy cruft from the prototyping phase.
* Detect sleep withSGX_INVALID_EINIT_TOKENinstead of counting power cycles.
* Manually prefix with ???sgx:??? in the core SGX code instead of redefiningpr_fmt.
* Report ifIA32_SGXLEPUBKEYHASHxMSRs are not writable in the driver instead of core because it is a driver requirement.
* Change prompt to bool in the entry forCONFIG_INTEL_SGX_COREbecause the default is ???n???.
* Rename structsgx_epc_bankas structsgx_epc_sectionin order to match the SDM.
* Allocate structsgx_epc_pageinstances one at a time.
* Use ???__iomem void *??? pointers for the mapped EPC memory consistently.
* Retry once onSGX_INVALID_TOKENinsgx_einit()instead of counting power cycles.
* Call enclave swapping operations directly from the driver instead of calling them .indirectly through structsgx_epc_page_opsbecause indirect calls are not required yet as the patch set does not contain the KVM support.
* Added special signalSEGV_SGXERRto notify about SGX EPCM violation errors.v13:
* Always useSGX_CPUIDconstant instead of a hardcoded value.
* Simplified and documented the macros and functions for ENCLS leaves.
* Enablesgx_free_page()to free active enclave pages on demand in order to allowsgx_invalidate()to delete enclave pages. It no longer performs EREMOVE if a page is in the process of being reclaimed.
* Use PM notifier per enclave so that we don't have to traverse the global list of active EPC pages to find enclaves.
* Removed unusedSGX_LE_ROLLBACKconstant fromuapi/asm/sgx.h
* Always useioremap()to map EPC banks as we only support 64-bit kernel.
* InvalidateIA32_SGXLEPUBKEYHASHcache used bysgx_einit()when going to sleep.v12:
* Split to more narrow scoped commits in order to ease the review process and use co-developed-by tag for co-authors of commits instead of listing them in the source files.
* Removed cruftEXPORT_SYMBOL()declarations and converted to static variables.
* Removed in-kernel LE i.e. this version of the SGX software stack only supports unlockedIA32_SGXLEPUBKEYHASHxMSRs.
* Refined documentation on launching enclaves, swapping and enclave construction.
* Refinedsgx_arch.hto include alignment information for every struct that requires it and removed structs that are not needed without an LE.
* Got rid ofSGX_CPUID.
* SGX detection now prints log messages about firmware configuration issues.v11:
* Polished ENCLS wrappers with refined exception handling.
* ksgxswapd was not stopped (regression in v5) insgx_page_cache_teardown(), which causes a leaked kthread after driver deinitialization.
* Shutdownsgx_le_proxywhen going to suspend because its EPC pages will be invalidated when resuming, which will cause it not function properly anymore.
* Set EINITTOKEN.VALID to zero for a token that is passed when SGXLEPUBKEYHASH matches MRSIGNER asalloc_page()does not give a zero page.
* Fixed the check insgx_edbgrd()for a TCS page. Allowed to read offsets around the flags field, which causes a #GP. Only flags read is readable.
* On read accessmemcpy()call insidesgx_vma_access()had src and dest parameters in wrong order.
* The build issue withCONFIG_KASANis now fixed. Added undefined symbols to LE even if ???KASAN_SANITIZE := false??? was set in the makefile.
* Fixed a regression in the #PF handler. If a page hasSGX_ENCL_PAGE_RESERVEDflag the #PF handler should unconditionally fail. It did not, which caused weird races when trying to change other parts of swapping code.
* EPC management has been refactored to a flat LRU cache and moved toarch/x86. The swapper thread reads a cluster of EPC pages and swaps all of them. It can now swap from multiple enclaves in the same round.
* For the sake of consistency withSGX_IOC_ENCLAVE_ADD_PAGE, return-EINVALwhen an enclave is already initialized or dead instead of zero.v10:
* Cleaned up anon inode based IPC between the ring-0 and ring-3 parts of the driver.
* Unset the reserved flag from an enclave page if EDBGRD/WR fails (regression in v6).
* Close the anon inode when LE is stopped (regression in v9).
* Update the documentation with a more detailed description of SGX.v9:
* Replaced kernel-LE IPC based on pipes with an anonymous inode. The driver does not require anymore new exports.v8:
* Check that public key MSRs match the LE public key hash in the driver initialization when the MSRs are read-only.
* Fix the race in VA slot allocation by checking the fullness immediately after succeesful allocation.
* Fix the race in hash mrsigner calculation between the launch enclave and user enclaves by having a separate lock for hash calculation.v7:
* Fixed offset calculation in sgx_edbgr/wr(). Address was masked withPAGE_MASKwhen it should have been masked with ~PAGE_MASK.
* Fixed a memory leak insgx_ioc_enclave_create().
* Simplified swapping code by using a pointer array for a cluster instead of a linked list.
* Squeezed structsgx_encl_pageto 32 bytes.
* Fixed deferencing of an RSA key on OpenSSL 1.1.0.
* Modified TC's CMAC to use kernel AES-NI. Restructured the code
a bit in order to better align with kernel conventions.v6:
* Fixed semaphore underrun when accessing/dev/sgxfrom the launch enclave.
* Insgx_encl_create()s/IS_ERR(secs)/IS_ERR(encl)/.
* Removed virtualization chapter from the documentation.
* Changed the default filename for the signing key as signing_key.pem.
* Reworked EPC management in a way that instead of a linked list of structsgx_epc_pageinstances there is an array of integers that encodes address and bank of an EPC page (the same data as 'pa' field earlier). The locking has been moved to the EPC bank level instead of a global lock.
* Relaxed locking requirements for EPC management. EPC pages can be released back to the EPC bank concurrently.
* Cleaned upptrace()code.
* Refined commit messages for new architectural constants.
* Sorted includes in every source file.
* Sorted local variable declarations according to the line length in every function.
* Style fixes based on Darren's comments tosgx_le.c.v5:
* Described IPC between the Launch Enclave and kernel in the commit messages.
* Fixed all relevant checkpatch.pl issues that I have forgot fix in earlier versions except those that exist in the imported TinyCrypt code.
* Fixed spelling mistakes in the documentation.
* Forgot to check the return value ofsgx_drv_subsys_init().
* Encapsulated properly page cache init and teardown.
* Collect epc pages to a temp list insgx_add_epc_bank
* RemovedSGX_ENCLAVE_INIT_ARCHconstant.v4:
* Tied life-cycle of thesgx_le_proxyprocess to/dev/sgx.
* Removed__exitannotation fromsgx_drv_subsys_exit().
* Fixed a leak of a backing page insgx_process_add_page_req()in the case whenvm_insert_pfn()fails.
* Removed unused symbol exports forsgx_page_cache.c.
* Updatedsgx_alloc_page()to require encl parameter and documented the behavior (Sean Christopherson).
* Refactored a more lean API forsgx_encl_find()and documented the behavior.
* Moved #PF handler tosgx_fault.c.
* Replacedsubsys_system_register()with plainbus_register().
* Retry EINIT 2nd time only if MSRs are not locked.v3:
* Check thatFEATURE_CONTROL_LOCKEDandFEATURE_CONTROL_SGX_ENABLEare set.
* Return-ERESTARTSYSin__sgx_encl_add_page()whensgx_alloc_page()fails.
* Use unused bits inepc_page->pato store the bank number.
* Removed #ifdef forWQ_NONREENTRANT.
* Ifmmu_notifier_register()fails with-EINTR, return-ERESTARTSYS.
* Added --remove-section=.got.plt to objcopy flags in order to prevent a dummy .got.plt, which will cause an inconsistent size for the LE.
* Documented sgx_encl_* functions.
* Added remark about AES implementation used inside the LE.
* Removed redundantsgx_sys_exit()fromle/main.c.
* Fixed structsgx_secinfoalignment from 128 to 64 bytes.
* Validate miscselect insgx_encl_create().
* Fixed SSA frame size calculation to take the misc region into account.
* Implemented consistent exception handling to__encls()and__encls_ret().
* Implemented a proper device model in order to allow sysfs attributes and in-kernel API.
* Cleaned up various "find enclave" implementations to the unifiedsgx_encl_find().
* Validate thatvm_pgoffis zero.
* Discard backing pages withshmem_truncate_range()after EADD.
* Added missing EEXTEND operations to LE signing and launch.
* Fixed SSA size for GPRS region from 168 to 184 bytes.
* Fixed the checks for TCS flags. Now DBGOPTIN is allowed.
* Check that TCS addresses are in ELRANGE and not just page aligned.
* Require kernel to be compiled withX64_64andCPU_SUP_INTEL.
* Fixed an incorrect value forSGX_ATTR_DEBUGfrom0x01to0x02.v2:
*get_rand_uint32()changed the value of the pointer instead of value where it is pointing at.
* Launch enclave incorrectly used sigstruct attributes-field instead of enclave attributes-field.
* Removed unused structsgx_add_page_reqfromsgx_ioctl.c
* Removed unusedsgx_has_sgx2.
* Updatedarch/x86/include/asm/sgx.hso that it provides stub implementations when sgx in not enabled.
* Removed cruft rdmsr-calls fromsgx_set_pubkeyhash_msrs().
* return-ENOMEMinsgx_alloc_page()when VA pages consume too much space
* removed unused globalsgx_nr_pids
* movedsgx_encl_releasetosgx_encl.c
* return-ERESTARTSYSinstead of-EINTRinsgx_encl_init()Jarkko Sakkinen (14):
x86/sgx: Add SGX architectural data structures x86/sgx: Add wrappers for ENCLS functions x86/cpu/intel: Add nosgx kernel parameter x86/sgx: Add SGX page allocator functions x86/sgx: Add SGX misc driver interface x86/sgx: AddSGX_IOC_ENCLAVE_CREATEx86/sgx: AddSGX_IOC_ENCLAVE_ADD_PAGESx86/sgx: AddSGX_IOC_ENCLAVE_INITx86/sgx: AddSGX_IOC_ENCLAVE_PROVISIONselftests/x86: Add a selftest for SGX x86/sgx: Add a page reclaimer
x86/sgx: Addptrace()support for the SGX driver
docs: x86/sgx: Document SGX kernel architecture x86/sgx: UpdateMAINTAINERSSean Christopherson (10):
x86/cpufeatures: x86/msr: Add Intel SGX hardware bits x86/cpufeatures: x86/msr: Add Intel SGX Launch Control hardware bits x86/sgx: Initialize metadata for Enclave Page Cache (EPC) sections x86/mm: x86/sgx: Signal SIGSEGV withPF_SGXx86/cpu/intel: Detect SGX support
mm: Add 'mprotect' hook to structvm_operations_structx86/vdso: Add support for exception fixup in vDSO functions x86/fault: Add helper function to sanitize error code x86/traps: Attempt to fixup exceptions in vDSO before signaling x86/vdso: Implement a vDSO for Intel SGX enclave call.../admin-guide/kernel-parameters.txt | 2 + .../userspace-api/ioctl/ioctl-number.rst | 1 + Documentation/x86/index.rst | 1 + Documentation/x86/sgx.rst | 211 +++++ MAINTAINERS | 13 + arch/x86/Kconfig | 17 + arch/x86/entry/vdso/Makefile | 8 +- arch/x86/entry/vdso/extable.c | 46 ++ arch/x86/entry/vdso/extable.h | 28 + arch/x86/entry/vdso/vdso-layout.lds.S | 9 +- arch/x86/entry/vdso/vdso.lds.S | 1 + arch/x86/entry/vdso/vdso2c.h | 50 +- arch/x86/entry/vdso/vsgx.S | 151 ++++ arch/x86/include/asm/cpufeatures.h | 2 + arch/x86/include/asm/disabled-features.h | 8 +- arch/x86/include/asm/enclu.h | 9 + arch/x86/include/asm/msr-index.h | 8 + arch/x86/include/asm/trap_pf.h | 1 + arch/x86/include/asm/vdso.h | 5 + arch/x86/include/uapi/asm/sgx.h | 168 ++++ arch/x86/kernel/cpu/Makefile | 1 + arch/x86/kernel/cpu/feat_ctl.c | 38 +- arch/x86/kernel/cpu/sgx/Makefile | 5 + arch/x86/kernel/cpu/sgx/arch.h | 338 ++++++++ arch/x86/kernel/cpu/sgx/driver.c | 194 +++++ arch/x86/kernel/cpu/sgx/driver.h | 29 + arch/x86/kernel/cpu/sgx/encl.c | 740 ++++++++++++++++++ arch/x86/kernel/cpu/sgx/encl.h | 121 +++ arch/x86/kernel/cpu/sgx/encls.h | 231 ++++++ arch/x86/kernel/cpu/sgx/ioctl.c | 716 +++++++++++++++++ arch/x86/kernel/cpu/sgx/main.c | 731 +++++++++++++++++ arch/x86/kernel/cpu/sgx/sgx.h | 77 ++ arch/x86/kernel/traps.c | 10 + arch/x86/mm/fault.c | 45 +- include/linux/mm.h | 7 + mm/mprotect.c | 7 + tools/testing/selftests/Makefile | 1 + tools/testing/selftests/sgx/.gitignore | 2 + tools/testing/selftests/sgx/Makefile | 53 ++ tools/testing/selftests/sgx/call.S | 44 ++ tools/testing/selftests/sgx/defines.h | 21 + tools/testing/selftests/sgx/load.c | 277 +++++++ tools/testing/selftests/sgx/main.c | 246 ++++++ tools/testing/selftests/sgx/main.h | 38 + tools/testing/selftests/sgx/sigstruct.c | 391 +++++++++ tools/testing/selftests/sgx/test_encl.c | 20 + tools/testing/selftests/sgx/test_encl.lds | 40 + .../selftests/sgx/test_encl_bootstrap.S | 89 +++ 48 files changed, 5232 insertions(+), 19 deletions(-) create mode 100644 Documentation/x86/sgx.rst create mode 100644 arch/x86/entry/vdso/extable.c create mode 100644 arch/x86/entry/vdso/extable.h create mode 100644 arch/x86/entry/vdso/vsgx.S create mode 100644 arch/x86/include/asm/enclu.h create mode 100644 arch/x86/include/uapi/asm/sgx.h create mode 100644 arch/x86/kernel/cpu/sgx/Makefile create mode 100644 arch/x86/kernel/cpu/sgx/arch.h create mode 100644 arch/x86/kernel/cpu/sgx/driver.c create mode 100644 arch/x86/kernel/cpu/sgx/driver.h create mode 100644 arch/x86/kernel/cpu/sgx/encl.c create mode 100644 arch/x86/kernel/cpu/sgx/encl.h create mode 100644 arch/x86/kernel/cpu/sgx/encls.h create mode 100644 arch/x86/kernel/cpu/sgx/ioctl.c create mode 100644 arch/x86/kernel/cpu/sgx/main.c create mode 100644 arch/x86/kernel/cpu/sgx/sgx.h create mode 100644 tools/testing/selftests/sgx/.gitignore create mode 100644 tools/testing/selftests/sgx/Makefile create mode 100644 tools/testing/selftests/sgx/call.S create mode 100644 tools/testing/selftests/sgx/defines.h create mode 100644 tools/testing/selftests/sgx/load.c create mode 100644 tools/testing/selftests/sgx/main.c create mode 100644 tools/testing/selftests/sgx/main.h create mode 100644 tools/testing/selftests/sgx/sigstruct.c create mode 100644 tools/testing/selftests/sgx/test_encl.c create mode 100644 tools/testing/selftests/sgx/test_encl.lds create mode 100644 tools/testing/selftests/sgx/test_encl_bootstrap.SSignature · 1 line
2.27.0
Jarkko Sakkinen
maintainerQuoted 7 lines · Chunyang
Tested-by Chunyang Hui <[email protected]>The Occlum project (https://occlum.io/) is a libOS built on top of Intel SGX feature. We ran Occlum tests using v5.10 kernel with SGX patch v41 on SGX hardware with the Flexible Launch Control (FLC) feature and didn't find any problems. As Occlum core developers, we would like these patches to be merged.
The patches and some fixes on top of them were pulled on Monday into mainline tree. I advice you to test v5.11-rc's when they become available and report any issues you might encounter.
/Jarkko