Root Trust Guest Memory Page Management
By employing a root-trusted guest with unique identifiers and separate page tables, the described technique addresses resource constraints in conventional access control, enhancing performance and scalability in managing virtual machine memory.
Patent Information
- Application Number
- JP2026523213
- Authority / Receiving Office
- JP · JP
- Patent Type
- Applications
- Current Assignee / Owner
- Priority Date
- 2023-10-24
- Filing Date
- 2024-10-24
- Publication Date
- 2026-11-19
AI Technical Summary
Conventional access control techniques for protecting guest virtual machine memory pages in computing systems are resource-constrained, leading to performance and scalability limitations, as they burden the security processor, causing bottlenecks and reducing the number of virtual machines that can be supported without significant latency impacts.
Implementing a root-trusted guest with unique identifiers and special privileges, allowing it to manage memory operations and offload encryption checks, while maintaining separate page tables and encryption schemes for each guest, thereby reducing computational overhead and enabling efficient memory access.
This approach enhances computing system performance by reducing power consumption, latency, and increasing bandwidth, allowing for improved scalability and efficient management of multiple virtual machines.
Smart Images

Figure 2026539002000001_ABST
Abstract
Description
TECHNICAL FIELD
[0001] (Priority) This application claims priority to U.S. Provisional Patent Application No. 63 / 592,916, filed October 24, 2023, the disclosure of which is hereby incorporated by reference in its entirety into the present specification. BACKGROUND ART
[0002] Computing systems often share data resources, such as in system architectures where different virtual machines access data stored in the computing system memory. To maintain the integrity of the computing system, private memory pages of guest virtual machines are protected via access control by a designated computing system processing unit such as a security processor. This access control prevents different virtual machines other than the guest virtual machine from reading from or writing to the private memory of the guest virtual machine. However, such access control presents challenges, as the designated processing unit performing the access control is resource-constrained, leading to limitations in the performance and scalability of the computing system. BRIEF DESCRIPTION OF THE DRAWINGS
[0003] [Figure 1] FIG. 1 is a block diagram of a non-limiting exemplary system having a hardware platform operable to enable memory page management for computing system guests by a root trusted guest using the techniques described herein. [Figure 2] FIG. 2 is a more detailed block diagram of a non-limiting exemplary system illustrating the hardware platform of FIG. 1 in which a root trusted guest accesses private memory pages of a guest to perform at least one operation. [Figure 3]This is a non-definitive, illustrative system block diagram showing in more detail the hardware platform in Figure 1 where the security processor performs access control checks on memory page requests from root trusted guests. [Figure 4] This is a non-limiting, illustrative block diagram illustrating the performance of a security processor selectively performing access control checks based on memory page requests from a root-trusted guest. [Figure 5] This is a non-restrictive, illustrative block diagram illustrating the process of generating page table entries for a computing system guest, where the page table entries define which system entities perform access control for guest memory page requests. [Modes for carrying out the invention]
[0004] In computing system architectures where different virtual machines access data stored in system memory, the private memory pages of a guest virtual machine are protected through access control by designated computing system compute units, such as a security processor. Security processor access control prevents unauthorized virtual machines from reading from or writing to the private memory of a guest virtual machine. In embodiments, access control is performed using a reverse mapping table, where the security processor compares the identifier of the guest virtual machine requesting access to a memory page with a table of values that correlates it with each private memory page that the virtual machine is permitted to access.
[0005] However, such access control presents challenges because it restricts the resources of the designated computing unit that implements the access control, limiting the performance and scalability of the computing system. For example, a computing unit subject to access control (e.g., a security processor) reduces computing resources (e.g., compared to a central processing unit), slows down memory access, and reduces processing power, creating a bottleneck that prevents the computing system from instantiating additional virtual machines without significantly impacting system latency. Thus, conventional access control techniques limit the number of virtual machines that can be supported by a given computing system.
[0006] To address these conventional shortcomings, root-trusted guest memory page management is described. In an embodiment, a root-trusted guest, such as a root framework secure virtual machine, is loaded by a computing system hardware platform and authenticated as a trusted entity. For example, a computing system virtual machine manager (e.g., a hypervisor) causes the root-trusted guest to generate a guest certification report containing information such as the authoring entity associated with the root-trusted guest (e.g., a developer), the security version number of the root-trusted guest, and the cryptographic measurements of the root-trusted guest's memory pages. For example, the virtual machine manager generates a hash representing the cryptographic measurements of private memory pages loaded from the root-trusted guest. Then, using the security version number and the authoring entity associated with the root-trusted guest, the security certificate provided by the authoring entity of the root-trusted guest is obtained.
[0007] The hash representing the cryptographic measurement of the private memory pages of the root-trusted guest is compared to the security certificate. Depending on whether the cryptographic hash measurement matches the security certificate, such a match means that the root-trusted guest is secure and trusted (e.g., the root-trusted guest's binary code is exactly the same as that released by the authoring entity). Alternatively, if the cryptographic hash measurement does not match the security certificate, such a mismatch is evidence of interference (e.g., malicious tampering by the root-trusted guest's binary code) and indicates that the root-trusted guest is untrustworthy (e.g., the virtual machine is considered a "guest" rather than a "root-trusted guest" by the computing system).
[0008] In response to authenticating a root-trusted guest loaded into a computing system, the root-trusted guest is assigned a unique identifier (e.g., an Address Space Identifier (ASID)). Other unique identifiers include cryptographic tokens, virtual machine identifiers, etc. The unique identifier assigned to a root-trusted guest is unique in that it can only be assigned to a single root-trusted guest and is immutable (e.g., it persists as long as the root-trusted guest is loaded into the computing system). When a root-trusted guest is loaded into a computing system, the designated security computing unit (e.g., a security processor) logs the unique identifier assigned to the root-trusted guest by writing it to an isolated area of computing system memory. The isolated memory area where the unique identifier is logged is accessible by the host components of the computing system (e.g., the central processing unit of the computing system) but inaccessible to computing system software and computing system guests other than the root-trusted guest that possess the logged unique identifier (e.g., virtual machines loaded into the computing system, the virtual machine monitor of the computing system, etc.).
[0009] While a guest is running (for example, performing one or more actions as part of executing a computing task) and issuing a request to access computing system resources (for example, a request to access data stored in computing system memory), the security processor compares the guest's unique identifier with a unique identifier stored in a separate memory area. Depending on whether the requesting guest has a unique identifier that matches the unique identifier stored in the separate memory area, the security processor allows the request to proceed. For example, in an exemplary scenario where the separate memory area stores a single unique identifier representing the root trusted guest, only requests from the root trusted guest are allowed, and requests from other guests are denied.
[0010] To mitigate the performance shortcomings faced by conventional systems, the described technique allows a root-trusted guest to manage the memory operations of different computing system guests (e.g., permitting requests from other guests loaded into the computing system). To do so, the computing system grants the root-trusted guest special privileges that allow it to perform memory operations using the guest's private memory pages (e.g., reading from and writing to the target guest page of a target guest). In embodiments, the target guest page represents a data structure maintained in the computing system's memory, associated with a unique identifier for the target guest (e.g., a unique identifier distinct from the unique identifier representing the root-trusted guest).
[0011] To maintain the security integrity of private memory pages associated with different guests, the computing system is configured to employ different encryption schemes for encrypting each guest's private memory pages. As described herein, an encryption scheme refers collectively to a combination of an encryption algorithm and an encryption key. Thus, the computing system is configured to protect a guest's private memory pages by using at least one encryption algorithm or encryption key that is not used to encrypt the private memory pages of a different guest. For example, the computing system might use an encryption algorithm and encryption key to encrypt the private memory pages of a root-trusted guest, and the same encryption algorithm and a different encryption key to encrypt the private memory pages of a different guest.
[0012] In some embodiments, the computing system uses a common encryption algorithm to encrypt private memory pages of different guests, using a different encryption key for each guest. In these embodiments, the computing system identifies the encryption key associated with each guest using a unique identifier assigned to each guest (for example, the computing system maintains a table of encryption key identifiers indexed by the guest's unique identifier). Due to the different encryption schemes protecting the private memory pages of different guests, a request to access the target guest's private memory pages from a root trust guest, identified by the root trust guest's unique identifier, would fail in a conventional system because the access control unit would identify the wrong encryption scheme to decrypt the target guest's private memory pages. For example, the computing system's access control unit identifies the root trust guest's unique identifier as corresponding to a first encryption scheme and attempts to decrypt the target guest's private memory pages using the first encryption scheme, while the target guest's private memory pages are protected using a second (e.g., different) encryption scheme. To avoid failures of such memory requests by the root trusted guest instead of the target guest, the technique described allows the root trusted guest to employ the target guest's unique identifier when communicating memory requests to the computing system. By enabling the root trusted guest to employ the target guest's unique identifier when requesting access to target guest memory pages, the target guest's unique identifier becomes available (e.g., by the computing system's security processor) to identify an appropriate encryption scheme for the target guest memory pages.
[0013] In an embodiment where a guest requests access to a page in the memory of the computing system on which the guest is loaded, the guest does not know the physical address of the memory page. Rather, the guest knows only the "guest virtual address" of the requested memory page. The guest then queries a guest page table that correlates the guest virtual address with the guest physical address. In the embodiment, the guest virtual address is translated to its guest physical address by walking through the guest page table. The computing system maintains a separate nested page table that can be used to translate the guest physical address of a memory page to the system physical address, thereby accurately identifying the requested memory page and placing it in the computing system's memory.
[0014] By maintaining a separate "guest page table" for guests from the "nested page tables," the computing system ensures that the system physical addresses of memory pages remain unknown to the guests. The computing system further maintains a reverse mapping ("RMP") table as a separate data structure from the guest page table and the nested page tables. The RMP table stores information describing which guests (identified, for example, by their respective unique identifiers) are permitted to access individual memory pages (identified, for example, by their respective system physical addresses).
[0015] After performing a nested page table walk to identify the system physical address of the requested memory page, the computing system performs an RMP check using the RMP table to verify whether the guest receiving the memory page request is authorized to access the system physical address of the memory page. To enable a root-trusted guest to service memory requests on behalf of other guests, the root-trusted guest is configured to maintain a guest page table (for example, in the computing system's memory) with a new "T bit" in each entry of the guest page table. The T bit is a single binary bit with a value (e.g., "1" or "0") that indicates whether the memory page is private to the root-trusted guest or to non-root-trusted guests. Setting the T bit entry of a target guest page to a defined value (e.g., "1") communicates to the computing system that the target guest page is a private page for non-root-trusted guests.
[0016] Since the root-trusted guest itself cannot map its guest physical address to the system physical address of a memory page, the computing system updates the root-trusted guest's guest page table to include the system physical address of the target guest's memory page if the T-bit entry of the target memory page is equal to 1 (for example, replacing the guest physical address in the root-trusted guest's guest page table for the target memory page with the appropriate system physical address). In this way, the root-trusted guest can map the guest virtual address of the request containing the target memory page to the appropriate system physical address and process the request using the system physical address instead of the guest physical address.
[0017] Each entry in the root-trusted guest's guest page table further includes a "C bit" (e.g., a ciphertext protection bit) that tells the computing system whether the corresponding memory page is a protected page (e.g., a guest's private memory page protected by the guest's encryption scheme). For example, a C bit value of 1 indicates that the corresponding memory page is a guest's private memory page, and a C bit value of 0 indicates that the corresponding memory page is a shared memory page. In the case of a memory request involving a memory page with an entry in the root-trusted guest's guest page table that has both a T bit value equal to 1 and a C bit value equal to 1, the computing system's page table walker (e.g., a compute unit) refrains from performing a nested page table walk. In other words, both T bit and C bit values equal to 1 for a root-trusted guest's guest page table entry indicate that the root-trusted guest's output mapping the guest virtual address of the target guest memory page to the guest physical address will return the correct system physical address of the target guest memory page.
[0018] Advantageously, this reduces the computational resources consumed by the computing system during nested page table walks (for example, by setting the T and C bit values to 1, the computing system's page table walker skips nested page table walks). By inserting the system physical addresses of the target guest's memory pages into the root-trusted guest's guest page table, the described technique advantageously allows the root-trusted guest to access and / or modify the target guest's private memory pages in a way that is not possible with conventional systems (e.g., reading from private memory pages, writing to private memory pages, moving private memory pages to different locations, etc.). The described technique further offloads the performance of RMP checks to the root-trusted guest, which is allowed to access the RMP table to identify a suitable cryptographic scheme for decrypting the target guest's private memory pages. For example, by storing a unique identifier for the root trusted guest in a separate memory area, the root trusted guest can access an RMP table indicating whether the target guest from which the memory request is being processed (e.g., by the root trusted guest) is permitted to access the system physical address where the requested memory page is stored. In this way, the techniques described herein enable hardware platforms to achieve technical advantages not provided by conventional system architectures (e.g., reduced power consumption, reduced latency, added bandwidth, etc.).
[0019] In some embodiments, the technology described herein relates to a system comprising: a hardware platform including physical computer hardware including at least one compute unit and at least one memory; a virtual machine monitor configured to virtualize the physical computer hardware of the hardware platform and instantiate a plurality of framework secure virtual machines; and a root framework secure virtual machine instantiated by the virtual machine monitor, configured to control access to at least one memory by the plurality of framework secure virtual machines.
[0020] In some embodiments, the technology described herein relates to a system in which at least one memory includes a guest page table containing a plurality of entries, each of which entries corresponds to at least one memory page loaded by the root framework secure virtual machine or one of the plurality of framework secure virtual machines.
[0021] In some embodiments, the techniques described herein relate to a system in which each of a plurality of entries includes a C bit having a value indicating whether the memory page is shared or private to the root framework secure virtual machine or to any of the plurality of framework secure virtual machines.
[0022] In some embodiments, the techniques described herein relate to a system in which each of a plurality of entries includes a T bit having a value indicating whether the memory page is private to the root framework secure virtual machine or to any of the plurality of framework secure virtual machines.
[0023] In some aspects, the techniques described herein relate to a system, wherein each of a plurality of entries in a guest page table includes a mapping of a guest virtual address to a guest physical address of a memory page, and at least one computation unit uses the guest physical address of the memory page as a system physical address of the memory page based on a T bit indicating that the memory page is private to any one of a plurality of framework secure virtual machines.
[0024] In some aspects, the techniques described herein relate to a system, wherein at least one memory includes a nested page table including a plurality of entries, and each of the plurality of entries maps a guest physical address to a system physical address for a memory page.
[0025] In some aspects, the techniques described herein relate to a system, wherein at least one computation unit, in response to a request from a root framework secure virtual machine to access a memory page, walks a nested page table to identify a system physical address of the memory page, and the memory page is a private memory page of the root framework secure virtual machine.
[0026] In some aspects, the techniques described herein relate to a system, wherein at least one computation unit, in response to a request from a root framework secure virtual machine to access a memory page, does not walk a nested page table to identify a system physical address of the memory page, and the memory page is a private memory page of any one of a plurality of framework secure virtual machines.
[0027] In some aspects, the techniques described herein relate to a system, wherein the request from the root framework secure virtual machine includes a request from a virtual machine monitor for managing the memory page on behalf of any one of the plurality of framework secure virtual machines.
[0028] In some embodiments, the technology described herein relates to a system, wherein at least one memory includes a reverse mapping table containing a plurality of entries, each of which includes a system physical address and at least one identifier of a guest permitted to access the system physical address, and the guest is either a root framework secure virtual machine or a plurality of framework secure virtual machines.
[0029] In some embodiments, the techniques described herein are configured such that at least one compute unit, using a reverse mapping table, verifies in response to a request to access a memory page from the root framework secure virtual machine that the root framework secure virtual machine is permitted access to the system physical address of at least one memory that stores the memory page, and the memory page is a private memory page of the root framework secure virtual machine.
[0030] In some embodiments, the techniques described herein relate to a system in which the root framework secure virtual machine is configured to use a reverse mapping table to verify that any of the multiple framework secure virtual machines is permitted access to the system physical address of at least one memory containing a memory page in response to a request from any of the multiple framework secure virtual machines to access the memory page, the memory page being a private memory page of any of the multiple framework secure virtual machines.
[0031] In some embodiments, the techniques described herein relate to a system in which the root framework secure virtual machine is configured to execute at least one command on behalf of the multiple framework secure virtual machines, which involves accessing memory pages that are private to at least one of the multiple framework secure virtual machines.
[0032] In some embodiments, the technology described herein relates to a system comprising physical computer hardware including at least one compute unit, memory storing guest page tables and nested page tables, and a virtual machine monitor configured to virtualize the physical computer hardware and instantiate a root framework secure virtual machine and at least one framework secure virtual machine, wherein the system is configured to service requests to access pages in memory by walking through the nested page tables using at least one compute unit, or by not walking through the nested page tables, depending on whether the pages in memory are private memory pages of the root framework secure virtual machine.
[0033] In some embodiments, the techniques described herein relate to a system in which a guest page table includes a plurality of entries, each of which includes a C bit having a value indicating whether a memory page is shared with or private to the root framework secure virtual machine or at least one framework secure virtual machine.
[0034] In some embodiments, the techniques described herein relate to a system in which a guest page table includes a plurality of entries, each of which includes a T bit having a value indicating whether a memory page is private to the root framework secure virtual machine or to at least one framework secure virtual machine.
[0035] In some embodiments, the techniques described herein relate to a system, wherein the system is configured to identify a page in memory as a private memory page of the root framework secure virtual machine, depending on whether the value of the T bit is zero.
[0036] In some embodiments, the techniques described herein relate to a system, wherein the system is configured to identify a page in memory as a private memory page of at least one framework-secure virtual machine, depending on the value of the T bit being 1.
[0037] In some embodiments, the techniques described herein relate to a system in which memory further stores a reverse mapping table, the system further configures to serve requests to access pages in memory by having at least one compute unit perform a reverse mapping check using the reverse mapping table, depending on whether the page in memory is a private memory page of a root framework secure virtual machine, or by having the root framework secure virtual machine perform a reverse mapping check using the reverse mapping table, depending on whether the page in memory is a private memory page of at least one framework secure virtual machine.
[0038] In some embodiments, the techniques described herein include a method comprising: a hardware platform including physical computer hardware receiving a request to access a memory page from a root framework secure virtual machine loaded onto the hardware platform; granting the request to access the memory page depending on whether the memory page is a private memory page of the root framework secure virtual machine; walking through nested page tables to identify the system physical address of the memory page and performing a reverse mapping table check using at least one compute unit of the physical computer hardware; or, depending on whether the memory page is a private memory page of a framework secure virtual machine other than the root framework secure virtual machine, performing a reverse mapping table check using the root framework secure virtual machine independently of walking through nested page tables.
[0039] Figure 1 is a block diagram of a non-limiting exemplary system 100 having a hardware platform capable of operating to enable memory page management for a compute system guest by a root trusted guest using the techniques described herein. In this example, system 100 includes a hardware platform 102, as well as a virtual machine monitor 104, one or more virtual machines 106, one or more framework secure virtual machines 108, and a root framework secure virtual machine 110, all running on the hardware platform 102.
[0040] In this example, the hardware platform 102 is shown to include a data fabric 112, one or more processing units 114, an embedded security processor 116, one or more memories 118, and a memory controller 120. Thus, according to the techniques described, one or more of the virtual machine monitor 104, virtual machines 106, framework secure virtual machines 108, and / or root framework secure virtual machines 110 operate by utilizing one or more of the underlying resources of the hardware platform 102 (e.g., one or more of the data fabric 112, processing units 114, embedded security processors 116, memories 118, or memory controllers 120). In one or more embodiments, one or more isolated regions of memory 118 (e.g., isolated memory region 122) are involved in implementing the guest memory page management techniques described herein.
[0041] In variations, the hardware platform 102 may include more, fewer, and / or different hardware components (e.g., caches, secondary storage devices, semiconductor intellectual property (IP) cores, etc.) without departing from the spirit or scope of the described technology. Furthermore, throughout the following description, various components of system 100 are referred to singly and / or plural, such as the hardware platform 102, the aforementioned components of the hardware platform 102 (e.g., one or more processing units 114), the virtual machine monitor 104, the virtual machine 106, the framework secure virtual machine 108, and / or the root framework secure virtual machine 110, etc. However, in embodiments, the number of components used to implement the described technology varies without departing from the spirit or scope of the described technology. While the use of one single embedded security processor 116 and one single root framework secure virtual machine 110 is described throughout, in at least one variation, multiple security processors and / or multiple root framework secure virtual machines are used to implement the described technology, such as in relation to multiple hardware platforms (e.g., used in data centers and / or by web service providers). According to one or more embodiments, the root framework secure virtual machine 110 is configured to run on multiple threads (e.g., multiple threads executed by the processing unit 114), which enables the root framework secure virtual machine 110 to simultaneously execute the guest memory page management techniques described herein.
[0042] In the illustrated example, the components described above (e.g., data fabric 112, one or more processing units 114, one or more memories 118, embedded security processor 116, memory controller 120, etc.) are shown as being included in the hardware platform 102. An example of the hardware platform 102 includes, but is not limited to, one or more system-on-a-chip (SoC) or system-on-a-package (SoP).
[0043] According to the described technology, one or more of the processing units 114, embedded security processors 116, memory 118, or memory controllers are coupled to each other via one or more wired or wireless connections (implemented, for example, using a data fabric 112). Exemplary wired connections include, but are not limited to, memory channels, buses (e.g., data buses, system or address buses), interconnects, through-silicon vias, traces, and planes. Other exemplary connections include optical connections, fiber optic connections, and / or connections or links based on quantum entanglement.
[0044] Examples of devices or apparatus on which System 100 is implemented include, but are not limited to, one or more server computers, personal computers (e.g., desktop or tower computers), smartphones or other wireless phones, tablet or phablet computers, notebook computers, laptop computers, wearable devices (e.g., smartwatches, augmented reality headsets or devices, virtual reality headsets or devices), entertainment devices (e.g., game consoles, portable game devices, streaming media players, digital video recorders, music or other audio playback devices, televisions, set-top boxes), Internet of Things (IoT) devices, automotive computers, and other computing devices or systems.
[0045] The processing unit 114 represents a computing unit of the hardware platform 102, such as an electronic circuit, that performs various operations on and / or using data in memory 118. Examples of processing units 114 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), a field-programmable gate array (FPGA), an accelerator, an accelerated processing unit (APU), and a digital signal processor (DSP). In at least one variation, all processing units 114 of the hardware platform 102 are of the same type (e.g., all CPUs, all CPUs of the same model, all GPUs, etc.). Alternatively, the hardware platform 102 includes at least two different types of processing units 114 (e.g., at least one CPU and at least one GPU, two different types of CPUs, a combination thereof, etc.). In some embodiments, although not shown in the example in Figure 1, the processing unit 114 includes registers configured to store data locally within the processing unit 114. In some embodiments, the processing unit 114 further includes dedicated circuits for performing specific functions (for example, a dedicated page table walker circuit for walking nested page tables, as will be described in more detail below).
[0046] Memory 118 is a device or system used by the processing unit 114 or by an in-memory processor (not shown in Figure 1) called an in-memory processing component or PIM component to store information for immediate use within the device. In one or more embodiments, memory 118 corresponds to a semiconductor memory in which data is stored in memory cells on one or more integrated circuits. In at least one example, memory 118 corresponds to or includes volatile memory, examples of which include random access memory (RAM), dynamic random access memory (DRAM), synchronous dynamic random access memory (SDRAM), static random access memory (SRAM), and memristors.
[0047] The memory 118 is packaged or configured in any of several different ways. Examples of such packaging or configurations include dual inline memory modules (DIMMs), small outline DIMMs (SO-DIMMs), registered DIMMs (RDIMMs), non-volatile DIMMs (NVDIMMs), ball grid array (BGA) memory permanently mounted (e.g., soldered, mounted, etc.) on a hardware platform 102 (or other printed circuit board), and combinations thereof.
[0048] Examples of DIMM types include, but are not limited to, synchronous dynamic random-access memory (SDRAM), double data rate (DDR) SDRAM, double data rate 2 (DDR2) SDRAM, double data rate 3 (DDR3) SDRAM, double data rate 4 (DDR4) SDRAM, and double data rate 5 (DDR5) SDRAM. In at least one variation, memory 118 is configured as or includes SO-DIMM or RDIMM according to any of the above standards (e.g., DDR, DDR2, DDR3, DDR4, and DDR5).
[0049] Alternatively or additionally, memory 118 may correspond to or include non-volatile memory, examples of which include flash memory, read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electronically erasable programmable read-only memory (EEPROM), and non-volatile random-access memory (NVRAM) such as phase-change memory (PCM) and magnetoresistive random-access memory (MRAM). Memory 118 can be configured in various ways to support thermal management using a tunable thermal management algorithm and / or to receive power managed using such a tunable algorithm.
[0050] Further examples of memory configurations include LPDDR, also known as low-power double data rate (LPDDR) SDRAM, which is a type of synchronous dynamic random access memory. In variations, LPDDR consumes less power than other types of memory and / or has a form factor suitable for devices such as mobile computers and cell phones. Examples of LPDDR include, but are not limited to, low-power double data rate 2 (LPDDR2), low-power double data rate 3 (LPDDR3), low-power double data rate 4 (LPDDR4), and low-power double data rate 5 (LPDDR5). It should be understood that memory 118 can be configured in various ways without departing from the spirit or scope of the described technology.
[0051] In at least one variation, the memory 118 of the hardware platform 102 is all of the same type (e.g., all DRAM, all DRAM of the same model, all MRAM, etc.). Alternatively, the hardware platform 102 includes at least two different types of processing units 114 (e.g., at least one DRAM and cache system, two different types of DRAM, a combination thereof, etc.).
[0052] The memory controller 120 is a hardware component or subsystem that manages the flow of data to and from the memory 118. For example, the memory controller 120 includes logic for reading from and writing to the memory 118, and an interface with the processing unit 114. In one or more embodiments, the memory controller 120 includes logic (not shown) for reading from and writing to various levels of the cache hierarchy. For example, the memory controller 120 receives instructions from the processing unit 114, which include accessing the memory 118, and the memory controller 120 provides data from the memory 118 to the processing unit 114 (for example, for processing by the processing unit 114). In one or more embodiments, the memory controller 120 is communicateable and / or topologically arranged between the processing unit 114 and the memory 118, and the memory controller 120 interfaces with both the processing unit 114 and the memory 118.
[0053] The virtual machine monitor 104 is a software and / or hardware component that virtualizes the physical computer hardware of the hardware platform 102. The virtual machine monitor 104 allocates and manages the physical resources of the hardware platform 102 to run one or more virtualized instances (i.e., virtual machines) of a computer on the hardware platform 102. The underlying computing device (e.g., the hardware platform 102) used by the virtual machine monitor to instantiate virtual machines is often called the “host.” In contrast, individual virtual machines instantiated using the hardware platform 102 are often called “guests.” In the context of system 100, the virtual machine monitor 104 allocates and manages the physical resources of the hardware platform 102, such as the processing unit 114, the embedded security processor 116, the memory 118, and / or the memory controller 120, to instantiate and / or manage one or more virtual machines. The virtual machine monitor is also called a “hypervisor,” and examples include Type 1 hypervisors (e.g., bare-metal hypervisors) and Type 2 hypervisors (e.g., hosted hypervisors).
[0054] In one or more embodiments, “virtual machine” is a virtualization or emulation of a computer system for providing the functionality of a physical computer system. In variations, the virtual system is a virtualization or emulation of a computer system having a range of functions, from, for example, providing a substitute for a real machine (e.g., instantiated with the resources used to run an entire operating system) to running computer programs in a platform-independent manner. In embodiments, the capabilities of a virtual machine and / or different virtual machines may vary without departing from the spirit or scope of the described technology.
[0055] According to the technology described, each of the following is a "virtual machine": one or more virtual machines 106, one or more framework-secure virtual machines 108, and the root framework-secure virtual machine 110.
[0056] However, one or more virtual machines 106, one or more framework-secure virtual machines 108, and the root framework-secure virtual machine 110 represent instantiations having different characteristics (e.g., being deployed according to a security framework) and / or different functions (e.g., managing the deployment of a security framework). In one or more embodiments, one or more virtual machines 106 are instantiated by the virtual machine monitor 104 using the underlying resources of the hardware platform 102, but the security of one or more virtual machines 106 is not managed according to a specific security framework.
[0057] One example of a security framework is SEV-SNP (Secure Encrypted Virtualization-Secure Nested Paging). The SEV-SNP framework builds upon the SEV and SEV-ES (Encryption State) functionalities while adding new hardware-based security protections. For example, SEV-SNP adds strong memory integrity protection to create isolated execution environments, preventing malicious hypervisor-based attacks such as data replay and memory remapping. SEV-SNP also introduces several additional optional security enhancements, such as supporting additional virtual machine usage models for stronger protection around interrupt behavior, and provides increased protection against side-channel attacks. In embodiments, specific security frameworks may differ from SEV-SNP without deviating from the described technologies.
[0058] In contrast to one or more virtual machines 106 that are not instantiated or managed according to a specific security framework (e.g., SEV-SNP), one or more framework-secure virtual machines 108 and the root framework-secure virtual machine 110 are implemented according to specific security techniques. Furthermore, the root framework-secure virtual machine 110 differs from the one or more framework-secure virtual machines 108 insofar as the root framework-secure virtual machine 110 is configured with elevated permissions (e.g., to access one or more parts of the hardware platform 102) and is capable of controlling various accesses of one or more parts of the hardware platform 102 by the one or more framework-secure virtual machines 108.
[0059] In conventional methods, some security frameworks are implemented using an embedded security processor 116 and / or without using a root framework secure virtual machine 110. For example, the conventional SEV-SNP method uses the embedded security processor 116 to perform guest management and trusted input / output (I / O) management of virtual machines within the security framework, such as one or more framework secure virtual machines 108. However, in one or more variations, the embedded security processor 116 is a slower (e.g., significantly slower) processor than the processing unit 114, and in one or more variations, it is implemented according to a family of composite instruction set computer (CISC) instruction set architectures such as x86. For example, compared to a processing unit 114 implemented according to such an instruction set architecture, the embedded security processor 116 has limited computation and memory resources.
[0060] Furthermore, the embedded security processor 116 experiences higher latency when accessing system memory (e.g., memory 118) to the processing unit 114. This reduces the throughput of the embedded security processor 116 when it reads from and writes to system memory during the management of one or more framework secure virtual machines 108 and other functions. These differences contribute to the higher latency in the SEV-SNP security services provided by the embedded security processor 116. Moreover, performance (e.g., throughput) and scaling issues worsen as the number of virtual machines deployed (e.g., by the virtual machine monitor 104) increases, along with the number of core accounts in newer platform hardware (e.g., processing units with more cores), and / or as new security features are added to keep pace with evolving data center regulations.
[0061] In contrast to conventional methods, the root framework secure virtual machine 110 is instantiated and works in cooperation with the embedded security processor 116 and virtual machine monitor 104 to implement the security framework (e.g., SEV-SNP). Since the root framework secure virtual machine 110 is permitted to use the processing unit 114 to perform management of one or more framework secure virtual machines 108 and / or trusted inputs / outputs (TIOs) (e.g., in x86), the described system 100 improves the performance (e.g., increased throughput, reduced latency, etc.) of a particular security framework (e.g., SEV-SNP) compared to conventional systems. Furthermore, the described system 100 also allows for easy scaling of the security features of the security framework, such as supporting various protocols including Secure Computation ExpressLink (CXL) and graphics processing unit (GPU) support.
[0062] The illustrated examples also show communication interfaces between various shown components, including interface 124, interface 126, interface 128, and interface 130. In one or more embodiments, interfaces 124, 126, 128, and 130 are at least partially activated and / or managed during runtime by the virtual machine monitor 104, leveraging various codes of the virtual machine monitor 104 (e.g., the hypervisor), and in accordance with a specific security framework (e.g., SEV-SNP). In one or more embodiments, interfaces 126 and 128 are protected in accordance with a specific security framework (e.g., their interfaces are encrypted), and as a result, even if the virtual machine monitor 104 facilitates such communication, the virtual machine monitor 104 cannot access (e.g., "see") the data being communicated through their interfaces. In contrast, interfaces 124 and 130 are not protected in the same way (e.g., interfaces 124 and 130 are not encrypted). In one or more embodiments, interfaces 124 and 130 are plaintext interfaces.
[0063] In one or more embodiments, interface 124 is used for communication of commands to the root framework secure virtual machine 110, which is available to the virtual machine monitor 104 for the management of one or more framework secure virtual machines 108. In one or more embodiments, interface 126 is used for communication of messages from one or more framework secure virtual machines 108 to the root framework secure virtual machine 110. In one or more embodiments, interface 128 is used for communication of messages from the root framework secure virtual machine 110 to the firmware 132 of the embedded security processor 116. In one or more embodiments, interface 130 is used for communication of firmware 132 commands for initializing the security framework and for managing the root framework secure virtual machine 110 (e.g., initialization, runtime management, and shutdown). The various messages communicated through these interfaces are described in more detail below.
[0064] The system 100 described above and below improves the performance of a particular security framework (e.g., SEV-SNP) by transferring the management of one or more framework secure virtual machines 108, trusted I / O, and other security functions from the firmware 132 of the embedded security processor 116 to hardware-protected software (e.g., the root framework secure virtual machine 110) running on an x86 processor, e.g., a processing unit 114. The described technology includes a set of hardware and firmware mechanisms, as well as system interfaces (e.g., interfaces 124-130), to enable the root framework secure virtual machine 110, privileged SNP virtual machines to perform secure virtual machine management. The improvement leverages existing SEV-SNP protections such as reverse mapping tables, memory encryption, and I / O protection to protect the execution of the root framework secure virtual machine 110 and provide special privileges through the processing unit 114 (e.g., CPU) and the firmware capabilities described herein.
[0065] In one or more embodiments, the functions of the firmware 132 of the processing unit 114 and the embedded security processor 116 include establishing and locking the runtime identity of the root framework secure virtual machine 110; making the root framework secure virtual machine 110 available for reading and writing pages of the target framework secure virtual machine 108; making the root framework secure virtual machine 110 available for reading and writing locations in memory 118 (e.g., isolated memory area 122) that are not available to x86 software (examples of these locations include the RMP table and fenced memory areas outside system memory); performing atomic updates with bitmasking of RMP table entries; flushing the translation lookaside buffer (TLB) for one or more framework secure virtual machines 108; securely loading and updating the software of the root framework secure virtual machine 110; and establishing an interface between the root framework secure virtual machine 110 and the embedded security processor 116.
[0066] The root framework secure virtual machine 110 is identified by its unique identifier (e.g., the ASID of the root framework secure virtual machine 110), but like one or more framework secure virtual machines 108, the security framework firmware 132 (implemented by, for example, the embedded security processor 116) establishes the root framework secure virtual machine 110 as a uniquely privileged root framework secure virtual machine 110 by writing the unique identifier of the root framework secure virtual machine 110 to a location in memory 118 that is accessible only to the processing unit 114 and the security framework firmware 132 (e.g., where the code for implementing the root framework secure virtual machine 110 is executed). This is done only after the security framework firmware 132 has verified the identity of the root framework secure virtual machine 110 by reading the identity block of the root framework secure virtual machine 110, which is initiated by the root framework secure virtual machine 110 itself during initialization. Once the unique identifier of the root framework secure virtual machine 110 is written to a fence memory location (e.g., isolated memory area 122), only the root framework secure virtual machine 110 or the embedded security processor 116 can clear that unique identifier when the root framework secure virtual machine 110 is shut down. The processing unit 114 (e.g., CPU) that executes code to implement the root framework secure virtual machine 110 checks whether the unique identifier of the root framework secure virtual machine 110 matches the unique identifier of the currently running framework secure virtual machine, and grants the currently running machine special privileges only if the unique identifiers match.
[0067] When the root framework secure virtual machine 110 is configured to read or write one or more private pages of the target framework secure virtual machine 108, the processing unit 114 uses the unique identifier of the target framework secure virtual machine 108, as well as the system physical address (SPA) of the pages of the target framework secure virtual machine 108. The root framework secure virtual machine 110 provides the unique identifier of the target framework secure virtual machine 108 to the processing unit 114 via a register, for example, by writing to a model-specific register (e.g., the target unique identifier model-specific register (MSR)).
[0068] In one or more embodiments, the root framework secure virtual machine 110 uses special coding in the root framework secure virtual machine 110's guest page table to tag one or more private memory pages of the target framework secure virtual machine 108 (e.g., memory pages loaded into memory 118 by the framework secure virtual machine 108). This special coding informs the processing unit 114 which memory page represented by the page table entry corresponds to the target framework secure virtual machine 108. In the example shown in Figure 1, the guest page table of the root framework secure virtual machine 110 is stored in memory 118 as the guest page table 134. Each entry in the guest page table 134 includes a "C bit" (e.g., a ciphertext protection bit) that identifies one or more pages (e.g., in memory 118) and tells the computing system whether the corresponding memory page is associated with a guest such as the framework secure virtual machine 108 or the root framework secure virtual machine 110. For example, a C bit value of 1 indicates that the corresponding memory page is a private memory page of the guest, and a C bit value of 0 indicates that the corresponding memory page is a shared memory page.
[0069] In the example shown in Figure 1, memory 118 is further shown as containing a nested page table 136. The nested page table 136 represents a data structure that stores information mapping the guest physical address to the system physical address of at least one memory page. In embodiments where a guest (e.g., framework-secure virtual machine 108 or root framework-secure virtual machine 110) requests access to a page in memory 118, the guest does not know the physical address of the memory page. Rather, the guest knows only the "guest virtual address" of the requested memory page. The guest then queries the guest page table (e.g., root framework-secure virtual machine 110 queries the guest page table 134), which correlates the guest virtual address with the guest physical address. In embodiments, the guest virtual address is translated to its guest physical address by walking through the guest page table 134. The hardware platform 102 maintains a separate nested page table 136 to translate guest physical addresses to system physical addresses of memory pages, thereby accurately identifying the requested memory page and placing it in memory 118.
[0070] The root framework secure virtual machine 110 represents a memory page belonging to the framework secure virtual machine 108 by setting the T bit value to 1, thereby causing the page table entry corresponding to the private page of the target framework secure virtual machine 108 to set a new software visibility bit (T bit). Conversely, the page table entry corresponding to the private page of the root framework secure virtual machine 110 is assigned a T bit value of zero. For page table entries in the guest page table 134 that have a T bit of 1, the hardware platform 102 (e.g., processing unit 114 or embedded security processor 116) treats the guest physical address of the memory page identified by the page table entry as being the same as the system physical address of the memory page.
[0071] For memory requests involving memory pages with entries in the guest page table 134 having a T-bit value equal to 1 and a C-bit value equal to 1, the computing system's page table walker (e.g., processing unit 114 or embedded security processor 116) refrains from performing a nested page table walk using the nested page table 136. The nested page table walk can be skipped because the processing unit 114 or embedded security processor 116 has modified the guest physical address of the entry in the guest page table 134 having a T-bit value equal to 1. Thus, the root framework secure virtual machine 110 can use the guest page table 134 to directly map the guest virtual address of the target memory page of the framework secure virtual machine 108 to the system physical address of the target memory page. Advantageously, this allows the root framework secure virtual machine 110 to process the memory request on behalf of the framework secure virtual machine 108 independently of (e.g., without) walking the nested page table 136.
[0072] The computing system further maintains a reverse mapping table 138 that represents data structures in memory 118, separate from the guest page table 134 and the nested page table 136. The reverse mapping table 138 represents data describing which guests (e.g., one or more framework secure virtual machines 108 and root framework secure virtual machine 110, each represented by its own unique identifier) are permitted to access pages in memory 118 (e.g., represented by their respective system physical addresses). In embodiments where the nested page table 136 is walked to identify the system physical address of a memory request (e.g., if the guest page table 134 entry for the requested memory page has a T-bit value of 0), the hardware platform 102 (e.g., the processing unit 114 or embedded security processor 116) examines the reverse mapping table 138 before allowing the memory request to proceed.
[0073] For example, after walking through the nested page table 136 to identify the system physical address of the requested memory page, the hardware platform 102 compares this to the unique identifier of the guest that received the memory request to determine whether the guest is permitted to access the system physical address. If the reverse mapping table 138 indicates that the guest identifier is permitted to access the system physical address, the hardware platform 102 allows the memory request to proceed (for example, via the virtual machine monitor 104). Alternatively, if the guest identifier is not permitted to access the system physical address, the memory request is rejected.
[0074] In embodiments where nested page table 136 walks are skipped (for example, when a memory request from the root framework secure virtual machine 110 relates to a page having a guest page table 134 entry with a T bit equal to 1), the technique described offloads the reverse mapping table 138 check to the root framework secure virtual machine 110. In embodiments, access to the reverse mapping table 138 is controlled by the embedded security processor 116 based on a unique identifier of the root framework secure virtual machine 110 maintained in an isolated memory area 122 (for example, the only guest permitted to access the reverse mapping table 138 is the guest having the unique identifier maintained in the isolated memory area 122).
[0075] When given access to the reverse mapping table 138, the root framework-secure virtual machine 110 can perform an RMP check to verify that the framework-secure virtual machine 108 is authorized to access the system physical address where the memory page is stored (for example, for a memory request handled by the root framework-secure virtual machine 108 on behalf of the framework-secure virtual machine 110, which contains the memory page). In some embodiments, the reverse mapping table 138 further includes information identifying a suitable cryptographic scheme for decrypting the target guest page in memory 118. As a particular example, after using the guest page table 134 to map the guest virtual address of a memory page requested by the framework-secure virtual machine 108 to a system physical address, the root framework-secure virtual machine 110 checks the reverse mapping table 138 to determine whether the unique identifier of the framework-secure virtual machine 108 is authorized to access the system physical address.
[0076] If permitted and the memory page at the system physical address is encrypted, the reverse mapping table 138 includes information identifying the encryption scheme used to encrypt the memory page (e.g., the encryption algorithm and encryption key assigned to the unique identifier of the framework secure virtual machine 108). The guest page table 134 and the reverse mapping table 138 thus enable the root framework secure virtual machine 110 to process memory requests on behalf of one or more framework secure virtual machines 108 by offloading operations that would otherwise have to be performed by at least one processing unit 114 and / or the embedded security processor 116.
[0077] According to the described technology, the existing flow for starting the framework secure virtual machine 108 is modified to detect the identity of the root framework secure virtual machine 110 during the startup process by verifying that the code of the root framework secure virtual machine 110 is signed and has an expected version number (e.g., including a security version number (SVN)). According to the specific security framework, the identity of the root framework secure virtual machine 110 is stored in the firmware 132 of the embedded security processor 116. When the root framework secure virtual machine 110 is first run by the virtual machine monitor 104 using a utility and / or command (e.g., VMRUN), the root framework secure virtual machine 110 invokes an initialization function in the firmware 132 (e.g., of the embedded security processor 116), which establishes the identity of the root framework secure virtual machine 110 for use by the processing unit 114 by writing the identity to a location accessible only to the processing unit 114 and the firmware 132. When the root framework secure virtual machine 110 terminates, it clears the memory of the processing unit 114 used to store the unique identifier (e.g., ASID) of the root framework secure virtual machine 110.
[0078] The interface 128 between the root framework secure virtual machine 110 and the embedded security processor 116 allows the root framework secure virtual machine 110 to provide commands via its private page, and allows the firmware 132 of the embedded security processor 116 to return responses by writing the responses directly to the private page of the root framework secure virtual machine 110, instead of using existing message-based protocols between one or more framework secure virtual machines 108 and the security framework firmware 132 (e.g., on the embedded security processor 116).
[0079] In at least one embodiment, the modification to the architecture of system 100 leverages a security framework (e.g., SNP) architecture to host a trusted software implementation module (e.g., at least one processing unit 114 of the code or binary to be executed) as a privileged root virtual machine (e.g., a root framework secure virtual machine 110). Furthermore, the root framework secure virtual machine 110 is protected using hardware security enforcement such as reverse mapping table protection and memory encryption.
[0080] In one or more embodiments, the root framework secure virtual machine 110 has a strong hardware-enforced identity that is signed by an authorized person, securely authenticated and loaded by an embedded security processor 116, can be checked by a processing unit 114 and firmware 132 before granting special privileges to the root framework secure virtual machine 110, has special hardware privileges that enable the root framework secure virtual machine 110 to perform guest management, trusted I / O and other functions, resides within the trusted compute base (TCB) of all framework secure virtual machines 108 and is included in the authentication of the framework secure virtual machines 108.
[0081] In one or more embodiments, the described system 100 redistributes responsibility to conventional technologies that leverage the security framework to improve scalability and reduce latency, among other improvements. In one or more embodiments, for example, the functions of the embedded security processor 116 after redistribution include initializing and shutting down the security framework, configuring the core, memory encryption engine and input / output (I / O) memory management unit (IOMMU), initializing the reverse mapping table (RMP) and microarchitecture structures, security framework trusted I / O (e.g., SEV-TIO initialization), trusted compute base (TCB) and authentication key management, management of the root framework secure virtual machine 110, low-level hardware functions for guest and trusted input / output (I / O) (also called "TIO" management), and programming of framework secure virtual machine keys in UMC, integrity and data encryption keys in RC, and data fabric flushing.
[0082] In one or more embodiments, the functions of the root framework secure virtual machine 110 include, after redistribution, managing one or more framework secure virtual machines 108, starting, activating and decommissioning one or more framework secure virtual machines 108, runtime management (e.g., page swap, move, unsmash, reuse, etc.), operation as a migration service, processing trusted I / O of the security framework (e.g., SEV-TIO processing), processing Trusted Execution Environment (TEE) Device Interface Security Protocol (TDISP) (e.g., Secure Protocol and Data Model (SPDM), integrity and data encryption key management), TEE device interface (TDI) management, strengthening the security framework, and processing of secure CXL memory / accelerator, scalable I / O virtualization (SIOV), etc., and can function as a device security manager for integrated devices such as DACC.
[0083] Figure 2 is a non-exclusive, exemplary block diagram of system 200 that provides a more detailed view of the hardware platform 102 in which a root trusted guest accesses the guest's private memory pages to perform at least one action. Specifically, Figure 2 shows the framework secure virtual machine 108 loaded onto the hardware platform 102, the root framework secure virtual machine 110, and the memory 118 of the hardware platform 102. When the framework secure virtual machine 108 is loaded, one or more private memory pages loaded from the framework secure virtual machine 108 are written to one or more physical addresses in memory 118.
[0084] The root framework-secure virtual machine 110 logs each private memory page of the framework-secure virtual machine 108 in the guest page table 134 (for example, it creates an entry in the guest page table 134 for each memory page of the framework-secure virtual machine 108). As part of logging each private page of the framework-secure virtual machine 108, the root framework-secure virtual machine 110 assigns a C bit value and a T bit value in the corresponding page table entry in the guest page table 134 (block 202). Specifically, for each page table entry representing a private page of the framework-secure virtual machine 108, the root framework-secure virtual machine 110 sets the C bit value to 1 and the T bit value to 1. In addition to including a C bit value indicating whether the corresponding memory page is private to the guest (for example, the framework-secure virtual machine 108 or the root framework-secure virtual machine 110) and a T bit value indicating whether the corresponding memory page is associated with the framework-secure virtual machine 108, each page table entry in the guest page table 134 includes a mapping of the guest virtual address of the page to its guest physical address.
[0085] The root framework secure virtual machine 110 identifies a page table entry in the guest page table 134 that has a T bit value equal to 1 and modifies the page table entry by mapping the guest virtual address of the memory page to that guest physical address, which is treated in relation to the system physical address of the memory page (block 204). In this way, the root framework secure virtual machine 110 updates the guest page table 134 so that the guest virtual address of the memory page is directly mapped to its location in memory 118 (e.g., the system physical address of the memory page).
[0086] Next, the root framework secure virtual machine 110 receives a request to execute at least one command that involves accessing a memory page identified by the guest virtual address (block 206). The root framework secure virtual machine 110 receives a request from the virtual machine monitor 104 via interface 124 to execute one or more commands and / or actions as part of performing a computation task using data stored in memory 118 (e.g., data private to the framework secure virtual machine 108), such as reading from memory 118, writing to memory 118, moving pages within memory 118, or a combination thereof.
[0087] As part of executing one or more commands or actions on behalf of a computing system guest (e.g., framework secure virtual machine 108), the root framework secure virtual machine 110 retrieves its guest page table from memory (block 208). For example, the root framework secure virtual machine 110 retrieves guest page table 134 from memory 118. Using the guest page table, the root framework secure virtual machine 110 maps the guest virtual address of a target guest memory page (e.g., the guest virtual address specified by the command received in block 206) to the system physical address of the target guest memory page (block 210). The mapping performed in block 204 configures the root framework secure virtual machine 110 to map the guest virtual address of a target guest memory page to its system physical address independently of walking through the nested page table 136.
[0088] Next, the root framework secure virtual machine 110 retrieves the reverse mapping table (block 212) and determines whether the framework secure virtual machine 108 is permitted to access the system physical address identified in block 210 instead of the root framework secure virtual machine 110 executing the command received in block 206. The root framework secure virtual machine 110 retrieves the reverse mapping table 138 from memory 118, for example, and performs a reverse mapping check (block 214). In some embodiments, the root framework secure virtual machine 110 performs a reverse mapping check by comparing the entry in the reverse mapping table 138 for the system physical address identified in block 210 with one or more corresponding unique identifiers representing guests permitted to access the system physical address in memory 118. In some embodiments, the command received in block 206 is further received by the root framework secure virtual machine 108 along with information describing the unique identifier of the framework secure virtual machine 110. In these embodiments, the unique identifier of the framework secure virtual machine 108 is compared with an entry in the reverse mapping table 138 to determine whether the framework secure virtual machine 108 is permitted to access the requested target guest memory page.
[0089] Upon passing the RMP check (for example, verifying that the framework secure virtual machine 108 is authorized to access one or more memory pages associated with the command received in block 206), the root framework secure virtual machine 110 retrieves memory page 216 from memory 118. In some embodiments, the root framework secure virtual machine 110 is configured to decrypt memory page 216 using the encryption scheme used to encrypt the private memory pages of the framework secure virtual machine 108. For example, the root framework secure virtual machine 110 uses a unique identifier associated with the framework secure virtual machine 108 to identify the encryption scheme used by the hardware platform 102 and encrypts memory page 216. In embodiments, the data structure correlating the encryption scheme with the guest unique identifier is maintained in memory, such as in the reverse mapping table 138 or in another data storage location accessible by the root framework secure virtual machine 110.
[0090] When the unencrypted version of memory page 216 is obtained, the root framework secure virtual machine 110 executes a command on behalf of the framework secure virtual machine 108 (block 218). In some embodiments, the root framework secure virtual machine 110 outputs a result 220 generated from executing the command in block 218, as indicated by the dashed arrow in Figure 2. For example, in an exemplary embodiment where the command is to read one or more values from memory page 216, the root framework secure virtual machine 110 outputs one or more values as result 220 to the framework secure virtual machine 108. Alternatively or additionally, in some embodiments, result 220 is output to a destination other than the framework secure virtual machine 108. For example, result 220 represents a value written to memory page 216, or another page in memory 118. Alternatively or additionally, result 220 represents a movement of memory page 216 to a different location in memory 118, and outputting result 220 involves updating at least one entry in the guest page table 134 to reflect the page movement. Therefore, although the exemplary result 220 is shown in Figure 2 as being output to the framework secure virtual machine 108 and / or memory 118, result 220 represents any output generated by the root framework secure virtual machine 108 as part of executing a command on behalf of the framework secure virtual machine 108 using data stored in the private memory pages of the framework secure virtual machine 110.
[0091] Consider Figure 3, in contrast to the example in Figure 2 where the root framework secure virtual machine 110 identifies the system physical address of the target guest page independently of walking through the nested page table 136.
[0092] Figure 3 is a non-definitive, exemplary system 300 block diagram that shows in more detail the hardware platform 102 in which the security processor performs access control checks on memory page requests from root trusted guests.
[0093] In the example shown in Figure 3, the root framework secure virtual machine 110 is shown executing a command that involves accessing a memory page identified by the guest virtual address (block 302). In block 302, the command that involves accessing a memory page identified by the guest virtual address represents, for example, a command that involves data stored in one or more private memory pages on the root framework secure virtual machine 110.
[0094] As part of executing the command, the root framework secure virtual machine 110 requests its guest page table from the hardware platform 102 via the virtual machine monitor 104 (block 304). The guest page table request causes the guest page table 134 to be returned to the root framework secure virtual machine 110 from memory 118 (block 306). Using the guest page table 134, the root framework secure virtual machine 110 maps the guest virtual addresses of the memory pages to their guest physical addresses (block 308).
[0095] Next, the root framework secure virtual machine 110 requests a memory page from the hardware platform 102 using the guest physical address (block 310). Based on the request, at least one processing unit 114 identifies that the page table entry in the guest page table 134 containing the guest physical address has a C bit value of 1 and a T bit value of 0 (block 312). Identifying that the guest physical address has a C bit value of 1 and a T bit value of 0 indicates that the requested page is private to the root framework secure virtual machine 110. Due to the T bit value being zero, the processing unit 114 identifies that it needs to walk through the nested page table 136 and retrieves the nested page table 136 from memory 118 (block 314).
[0096] The processing unit 114 then identifies the system physical address by walking through the nested page table 136 using the guest physical address (block 316). The processing unit 114 then retrieves the reverse mapping table 138 (block 318) and performs RMP verification (block 320) to evaluate whether the root framework secure virtual machine 110 is permitted to access the system physical address obtained from the walk through the nested page table 136. Unless the root framework secure virtual machine 110 passes the RMP verification for accessing the requested system physical address, the processing unit 114 denies access to the requested memory page. Alternatively, depending on whether the reverse mapping table 138 indicates that the root framework secure virtual machine 110 is permitted to access the system physical address, the processing unit 114 grants access and communicates the requested memory page to the root framework secure virtual machine 110 (block 322). The root framework secure virtual machine 110 then executes a command using the data stored in the memory page (block 324).
[0097] Figure 4 is a block diagram of a non-exclusive, illustrative procedure 400 that illustrates the performance of the security processor selectively performing access control checks based on memory page requests from root trusted guests.
[0098] First, a request to access a memory page is received from the root framework secure virtual machine (block 402). The hardware platform 102 receives, for example, a request from the root framework secure virtual machine 110 to access a page in memory 118 via the virtual machine monitor 104. In this embodiment, the request is received along with information describing the guest virtual address of the memory page being requested.
[0099] Upon receiving a request, a determination is made as to whether the page table entry for the requested memory page contains a C bit value equal to 1 (block 404). Processing unit 114 identifies the page table entry in the guest page table 134 based, for example, on the guest virtual address received as part of the request from the root framework secure virtual machine 110. Depending on whether it has identified that the page table entry contains a C bit value of zero (e.g., block 404: "No"), processing unit 114 grants access to the requested memory page (block 406). Identifying a C bit value of 0 in the guest page table 134 indicates that the requested memory page is a shared page that the root framework secure virtual machine 110 is permitted to access, and processing unit 114 uses this information to grant the request.
[0100] Alternatively, in response to determining that the page table entry contains a C bit value of 1 (e.g., block 404: "yes"), processing unit 114 evaluates whether the page table entry contains a T bit value of 0 (block 408). Processing unit 114 identifies the page table entry in the guest page table 134 based, for example, on the guest virtual address received as part of a request from the root framework secure virtual machine 110. In response to determining that the page table entry contains a T bit value of zero (e.g., block 408: "no"), a nested page table walk is performed to identify the system physical address of the memory page, and a reverse mapping table check is performed to verify that the root framework secure virtual machine is authorized to access the system physical address (block 410).
[0101] The processing unit 114 identifies, for example, that the C bit value of 1 and the T bit value of 0 in the page table entry for the requested page indicate that the requested page is a private page of the root framework secure virtual machine 110. Based on this information, the processing unit 114 identifies that the root framework secure virtual machine 110 does not know the system physical address that identifies where in memory 118 the requested page is stored, and that the request from the root framework secure virtual machine 110 to access the memory page includes the guest physical address of the memory page. The processing unit 114 then walks through the nested page table 136 to identify the system physical address mapped to the guest physical address in the nested page table 136.
[0102] After identifying the system physical address via a nested page table 136 walk, the processing unit 114 uses the reverse mapping table 138 to perform an RMP check to determine whether the root framework secure virtual machine 110 (represented, for example, by its unique identifier) is permitted to access the system physical address in memory 118. Based on the data contained in the reverse mapping table 138, a determination is made as to whether the guest requesting access to the memory page (e.g., the root framework secure virtual machine 110) will pass the RMP check (block 412). If it is determined that the requesting guest will not pass the RMP check (e.g., block 412: "no"), the request is denied and the requesting guest is denied access to the requested memory page (block 414). Alternatively, if it is determined that the requesting guest has passed the RMP check (e.g., block 412: "yes"), the operation of step 400 proceeds to block 406, and the requesting guest is granted access to the memory page. For example, the requested memory page is communicated to the root framework secure virtual machine 110.
[0103] Returning to block 408, processing unit 114 identifies that the page table entry for the requested memory page contains a T bit value of 1 (e.g., block 408: "Yes"). In an alternative embodiment, the root framework secure virtual machine 110 performs the RMP check without a nested page table walk (block 416). The T bit value of 1, combined with a C bit value of 1, in the page table entry indicates that the requested memory page is a private page of the framework secure virtual machine 108. Thus, the T bit and C bit values of 1 indicate that the root framework secure virtual machine 110 is requesting access to the memory page on behalf of the framework secure virtual machine 108. By setting the T bit value to 1, the root framework secure virtual machine 110 treats the guest physical address of the memory page in the guest page table 134 as the system physical address of the memory page, so that a walk through the nested page table 136 is unnecessary and not performed by the hardware platform 102.
[0104] A T bit value of 1 indicates that the root framework secure virtual machine 110 can perform an RMP check (for example, using the reverse mapping table 138, the root framework secure virtual machine 110 determines whether the framework secure virtual machine 108, which is handling the memory request, is permitted to access the system physical address that defines the storage location of the requested memory page). As the operation of step 400 proceeds from block 416 to block 412, the determination of whether the RMP check passed is offloaded to the root framework secure virtual machine 110, which communicates the result of the RMP check to the virtual machine monitor 104 to either deny access to the requested memory page or retrieve the requested memory page on behalf of the framework secure virtual machine 108.
[0105] Figure 5 is a block diagram of a non-restrictive, illustrative procedure 500 illustrating the generation of page table entries for a computing system guest, where the page table entries define which system entities perform access control for guest memory page requests.
[0106] In the example shown in Figure 5, the framework secure virtual machine is registered with the hardware platform (block 502). The embedded security processor 116, for example, registers the root framework secure virtual machine 110 with the hardware platform 102, and optionally registers at least one framework secure virtual machine 108 with the hardware platform 102.
[0107] One or more pages of a framework secure virtual machine are loaded into the hardware platform's memory (block 504). For example, as part of registration with hardware platform 102, the root framework secure virtual machine 110 loads at least one page into memory 118 (e.g., via communication with hardware platform 102 via interface 124, interface 128, or a combination thereof). Alternatively or additionally, as part of registration with hardware platform 102, the framework secure virtual machine 108 loads at least one page into memory 118 (e.g., by communicating at least one memory page to the root framework secure virtual machine 110 via interface 126, and then routing at least one memory page to hardware platform 102 via interface 124, interface 128, or a combination thereof).
[0108] As part of loading one or more pages of a framework-secure virtual machine into the hardware platform's memory, a page table entry is generated for each of the one or more pages, and the page table entry includes a configurable T bit and a configurable C bit to indicate memory page ownership (block 506). For example, a page table entry is generated in the guest page table 134 of the root framework-secure virtual machine 110 for each memory page loaded into memory 118 by the root framework-secure virtual machine 110 and / or framework-secure virtual machine 108.
[0109] As part of generating page table entries for guest memory pages loaded onto hardware platform 102, a determination is made as to whether a memory page is a shared ownership page (block 508). For example, processing unit 114 determines whether the memory page identified by the page table entry is private to the system guest (e.g., private to the framework secure virtual machine 108 or private to the root framework secure virtual machine 110) or a shared memory page that is permitted to be accessed by different entities.
[0110] If it is determined that the memory page is a shared memory page (e.g., block 508: "yes"), the page table entry for the memory page is configured to have a C bit value of zero and a T bit value of zero (block 510). Alternatively, if it is determined that the memory page is a private memory page for the system guest (e.g., block 508: "no"), the operation of step 500 proceeds to determine whether the memory page is private to the root framework secure virtual machine (block 512).
[0111] The processing unit 114 compares, for example, the unique identifier of the guest receiving the memory page identified by the page table entry with a unique identifier stored in the isolated memory area 122 of memory 118. Since the unique identifier stored in the isolated memory area 122 identifies the root framework secure virtual machine 110, upon detecting that the unique identifier of the system guest associated with the loaded memory page matches the unique identifier stored in the isolated memory area 122, the processing unit 114 identifies that the memory page is private to the root framework secure virtual machine 110 (e.g., block 512: "yes"). Upon identifying that the memory page is private to the root framework secure virtual machine 110, the page table entry for the memory page is configured to have a C bit value of 1 and a T bit value of 0 (block 514). This combination of a C bit value of 1 and a T bit value of 0 indicates that the memory page associated with the page table entry is private to the root framework secure virtual machine 110.
[0112] Alternatively, depending on whether the memory page is identified as a private memory page of a system guest other than the root framework secure virtual machine 110 (e.g., block 512: "No"), the page table entry for the memory page is configured to have a C bit value of 1 and a T bit value of 1 (block 516). This combination of a C bit value of 1 and a T bit value of 1 indicates that the memory page associated with the page table entry is private to guests other than the root framework secure virtual machine 110, such as the framework secure virtual machine 108.
[0113] A T bit value of 1 causes the root framework secure virtual machine 110 to treat the guest physical address of a memory page in its page table entry as the system physical address of the memory page in memory 118, thereby enabling the root framework secure virtual machine 110 to process memory requests on behalf of the framework secure virtual machine 108 without the hardware platform 102 having to walk through the nested page table 136. A T bit value of 1 further indicates that RMP checks (e.g., using the reverse mapping table 138) are performed by the root framework secure virtual machine 110, thus offloading the responsibility of RMP checks that would otherwise be performed by the compute units of the hardware platform 102.
[0114] Therefore, the new T bit in the page table entry favorably reduces the computational resources consumed by the computing system during nested page table walks (for example, by setting the T bit and C bit values to 1, the computing system's page table walker skips nested page table walks). By inserting the system physical addresses of the target guest's memory pages into the root trusted guest's guest page table, the technique described favorably allows the root trusted guest to access and / or modify the target guest's private memory pages in ways that would not be possible with conventional systems (e.g., reading from private memory pages, writing to private memory pages, moving private memory pages to different locations, etc.).
[0115] The techniques described further offload the performance of RMP checks to the root-trusted guest, which is then permitted to access the RMP table to identify the appropriate cryptographic scheme for decrypting the target guest's private memory pages. For example, by storing the root-trusted guest's unique identifier in a separate memory area, the root-trusted guest can access the RMP table indicating whether the target guest from which the memory request is being processed (e.g., by the root-trusted guest) is permitted to access the system physical address where the requested memory page is stored. In this way, the techniques described herein enable hardware platforms to achieve technical advantages not provided by conventional system architectures (e.g., reduced power consumption, reduced latency, added bandwidth, etc.).
[0116] Various embodiments are possible based on the disclosure herein, and the technology described is not limited to the specific examples described above. Although features and elements are described above in specific combinations, each feature or element can be used alone without other features and elements, or in various combinations with or without other features and elements.
[0117] The various functional units described in the drawings and / or herein (including, where appropriate, a hardware platform 102 having a processing unit 114, an embedded security processor 116, memory 118, and a memory controller 120) are implemented in any of several different ways, such as hardware circuits, software, or firmware running on a programmable processor, or any combination of two or more of hardware, software, and firmware. The methods provided are implemented in any of several devices, such as general-purpose computers, processors, or processor cores. Suitable processors include, by example, general-purpose processors, dedicated processors, conventional processors, digital signal processors (DSPs), graphics processing units (GPUs), parallel accelerators, multiple microprocessors, one or more microprocessors associated with a DSP core, controllers, microcontrollers, application-specific integrated circuits (ASICs), field-programmable gate array (FPGA) circuits, any other type of integrated circuit (IC), and / or state machines.
[0118] In one or more embodiments, the methods and procedures provided herein are implemented in computer programs, software, or firmware embedded in a non-temporary computer-readable storage medium for execution by a general-purpose computer or processor. Examples of non-temporary computer-readable storage media include read-only memory (ROM), random-access memory (RAM), registers, cache memory, semiconductor memory devices, magnetic media such as internal hard disks and removable disks, magneto-optical media, and optical media such as CD-ROM disks and digital versatile disks (DVDs).
Claims
1. It is a system, A hardware platform comprising physical computer hardware, wherein the physical computer hardware includes at least one computing unit and at least one memory, A virtual machine monitor configured to virtualize the physical computer hardware of the hardware platform and instantiate multiple framework-secure virtual machines, A root framework secure virtual machine instantiated by the virtual machine monitor, the root framework secure virtual machine configured to control access to the at least one memory by the plurality of framework secure virtual machines, comprises system.
2. The at least one memory includes a guest page table containing a plurality of entries, each of which corresponds to at least one memory page loaded by the root framework secure virtual machine or any of the plurality of framework secure virtual machines. The system according to claim 1.
3. Each of the aforementioned entries includes a C bit having a value indicating that the memory page is shared, or that the memory page is private to the root framework secure virtual machine or any of the aforementioned framework secure virtual machines. The system according to claim 2.
4. Each of the aforementioned entries includes a T bit having a value indicating that the memory page is private to the root framework secure virtual machine, or that the memory page is private to any of the aforementioned framework secure virtual machines. The system according to claim 2 or 3.
5. Each of the plurality of entries in the guest page table includes a mapping of a guest virtual address to the guest physical address of the memory page, and the at least one compute unit uses the guest physical address of the memory page as the system physical address of the memory page, based on the T bit indicating that the memory page is private to any of the plurality of framework secure virtual machines. The system according to claim 4.
6. The at least one memory includes a nested page table containing a plurality of entries, each of which maps a guest physical address to the system physical address of a memory page. The system according to claim 1.
7. The at least one computing unit, in response to a request from the root framework secure virtual machine to access the memory page, walks through the nested page table to identify the system physical address of the memory page, and the memory page is a private memory page of the root framework secure virtual machine. The system according to claim 6.
8. The at least one computing unit, in response to a request from the root framework secure virtual machine to access the memory page, identifies the system physical address of the memory page without walking the nested page table, and the memory page is a private memory page of one of the plurality of framework secure virtual machines. The system according to claim 6.
9. The request from the root framework secure virtual machine includes a request from the virtual machine monitor to manage the memory pages on behalf of any of the multiple framework secure virtual machines. The system according to claim 8.
10. The at least one memory includes a reverse mapping table containing a plurality of entries, each of which includes a system physical address and at least one identifier of a guest permitted to access the system physical address, wherein the guest is either the root framework secure virtual machine or one of the plurality of framework secure virtual machines. The system according to claim 1.
11. The at least one compute unit is configured to use the reverse mapping table to verify that the root framework secure virtual machine is permitted access to the system physical address of the at least one memory that stores the memory page in response to a request from the root framework secure virtual machine to access the memory page, wherein the memory page is a private memory page of the root framework secure virtual machine. The system according to claim 10.
12. The root framework secure virtual machine is configured to use the reverse mapping table to verify that any of the multiple framework secure virtual machines is authorized to access the system physical address of at least one memory containing the memory page in response to a request from any of the multiple framework secure virtual machines to access the memory page, wherein the memory page is a private memory page of any of the multiple framework secure virtual machines. The system according to claim 10.
13. The root framework secure virtual machine is configured to execute at least one command on behalf of the multiple framework secure virtual machines, which involves accessing a memory page that is private to at least one of the multiple framework secure virtual machines. The system according to claim 1.
14. It is a system, Physical computer hardware comprising at least one processing unit and memory for storing guest page tables and nested page tables, The system comprises a virtual machine monitor configured to virtualize the aforementioned physical computer hardware and instantiate a root framework secure virtual machine and at least one framework secure virtual machine, The aforementioned system, The system is configured to process requests to access pages in memory by using at least one compute unit to walk through the nested page table, or by not walking through the nested page table, depending on whether the page in memory is a private memory page of the root framework secure virtual machine. system.
15. It is a method, A hardware platform, including physical computer hardware, receives a request to access a memory page from a root framework secure virtual machine loaded onto the hardware platform, The following are included in allowing a request to access the memory page: depending on whether the memory page is a private memory page of the root framework secure virtual machine, walking through the nested page table to identify the system physical address of the memory page and performing a reverse mapping table check using at least one compute unit of the physical computer hardware; or depending on whether the memory page is a private memory page of a framework secure virtual machine other than the root framework secure virtual machine, performing the reverse mapping table check using the root framework secure virtual machine independently of walking through the nested page table; method.
