Merge pull request #261 from intel/ept-clean-up

Remove legacy EPT engine

Author: wcwang

core/ept.c

@@ -37,11 +37,8 @@
  *    mapping.
  */
 
-#include "../include/hax.h"
 #include "include/ept.h"
 #include "include/cpu.h"
-#include "include/paging.h"
-#include "include/vtlb.h"
 
 static uint64_t ept_capabilities;
 
@@ -77,251 +74,6 @@ static bool ept_has_cap(uint64_t cap)
     return (ept_capabilities & cap) != 0;
 }
 
-// Get the PDE entry for the specified gpa in EPT
-static epte_t * ept_get_pde(struct hax_ept *ept, hax_paddr_t gpa)
-{
-    epte_t *e;
-    uint which_g = gpa >> 30;
-    // PML4 and PDPTE level needs 2 pages
-    uint64_t offset = (2 + which_g) * PAGE_SIZE_4K;
-    // Need Xiantao's check
-    unsigned char *ept_addr = hax_page_va(ept->ept_root_page);
-
-    hax_assert(which_g < EPT_MAX_MEM_G);
-
-    e = (epte_t *)(ept_addr + offset) + ept_get_pde_idx(gpa);
-    return e;
-}
-
-// ept_set_pte: caller can use it to setup p2m mapping for the guest.
-bool ept_set_pte(hax_vm_t *hax_vm, hax_paddr_t gpa, hax_paddr_t hpa, uint emt,
-                 uint mem_type, bool *is_modified)
-{
-    bool ret = true;
-    struct hax_page *page;
-    hax_paddr_t pte_ha;
-    epte_t *pte;
-    void *pte_base, *addr;
-    struct hax_ept *ept = hax_vm->ept;
-    uint which_g = gpa >> 30;
-    uint perm;
-    epte_t *pde = ept_get_pde(ept, gpa);
-
-    // hax_log(HAX_LOGD, "hpa %llx gpa %llx\n", hpa, gpa);
-    if (which_g >= EPT_MAX_MEM_G) {
-        hax_log(HAX_LOGE, "Error: Guest's memory size is beyond %dG!\n",
-                EPT_MAX_MEM_G);
-        return false;
-    }
-    hax_mutex_lock(hax_vm->vm_lock);
-    if (!epte_is_present(pde)) {
-        if (mem_type == EPT_TYPE_NONE) {  // unmap
-            // Don't bother allocating the PT
-            goto out_unlock;
-        }
-
-        page = hax_alloc_page(0, 1);
-        if (!page) {
-            ret = false;
-            goto out_unlock;
-        }
-
-        hax_list_add(&page->list, &ept->ept_page_list);
-        addr = hax_page_va(page);
-        memset(addr, 0, PAGE_SIZE_4K);
-        pte_ha = hax_page_pa(page);
-        // Always own full access rights
-        epte_set_entry(pde, pte_ha, 7, EMT_NONE);
-    }
-
-    // Grab the PTE entry
-    pte_base = hax_vmap_pfn(pde->addr);
-    if (!pte_base) {
-        ret = false;
-        goto out_unlock;
-    }
-    pte = (epte_t *)pte_base + ept_get_pte_idx(gpa);
-    // TODO: Just for debugging, need check QEMU for more information
-    /* if (epte_is_present(pte)) {
-     *     hax_log(HAX_LOGD, "Can't change the pte entry!\n");
-     *     hax_mutex_unlock(hax_vm->vm_lock);
-     *     hax_log(HAX_LOGD, "\npte %llx\n", pte->val);
-     *     hax_vunmap_pfn(pte_base);
-     *     return 0;
-     * }
-     */
-    switch (mem_type) {
-        case EPT_TYPE_NONE: {
-            perm = 0;  // unmap
-            break;
-        }
-        case EPT_TYPE_MEM: {
-            perm = 7;
-            break;
-        }
-        case EPT_TYPE_ROM: {
-            perm = 5;
-            break;
-        }
-        default: {
-            hax_log(HAX_LOGE, "Unsupported mapping type 0x%x\n", mem_type);
-            ret = false;
-            goto out_unmap;
-        }
-    }
-    *is_modified = epte_is_present(pte) && (epte_get_address(pte) != hpa ||
-                   epte_get_perm(pte) != perm || epte_get_emt(pte) != emt);
-    epte_set_entry(pte, hpa, perm, emt);
-
-out_unmap:
-    hax_vunmap_pfn(pte_base);
-out_unlock:
-    hax_mutex_unlock(hax_vm->vm_lock);
-    return ret;
-}
-
-static bool ept_lookup(struct vcpu_t *vcpu, hax_paddr_t gpa, hax_paddr_t *hpa)
-{
-    epte_t *pde, *pte;
-    void *pte_base;
-    struct hax_ept *ept = vcpu->vm->ept;
-    uint which_g = gpa >> 30;
-
-    hax_assert(ept->ept_root_page);
-    if (which_g >= EPT_MAX_MEM_G) {
-        hax_log(HAX_LOGD, "ept_lookup error!\n");
-        return 0;
-    }
-
-    pde = ept_get_pde(ept, gpa);
-
-    if (!epte_is_present(pde))
-        return 0;
-
-    pte_base = hax_vmap_pfn(pde->addr);
-    if (!pte_base)
-        return 0;
-
-    pte = (epte_t *)pte_base + ept_get_pte_idx(gpa);
-
-    if (!epte_is_present(pte)) {
-        hax_vunmap_pfn(pte_base);
-        return 0;
-    }
-
-    *hpa = (pte->addr << 12) | (gpa & 0xfff);
-    hax_vunmap_pfn(pte_base);
-    return 1;
-}
-
-/*
- * Deprecated API of EPT
- * Translate a GPA to an HPA
- * @param vcpu:     current vcpu structure pointer
- * @param gpa:      guest physical address
- * @param order:    order for gpa
- * @param hpa       host physical address pointer
- */
-
-// TODO: Do we need to consider cross-page case ??
-bool ept_translate(struct vcpu_t *vcpu, hax_paddr_t gpa, uint order, hax_paddr_t *hpa)
-{
-    hax_assert(order == PG_ORDER_4K);
-    return ept_lookup(vcpu, gpa, hpa);
-}
-
-static eptp_t ept_construct_eptp(hax_paddr_t addr)
-{
-    eptp_t eptp;
-    eptp.val = 0;
-    eptp.emt = EMT_WB;
-    eptp.gaw = EPT_DEFAULT_GAW;
-    eptp.asr = addr >> PG_ORDER_4K;
-    return eptp;
-}
-
-bool ept_init(hax_vm_t *hax_vm)
-{
-    uint i;
-    hax_paddr_t hpa;
-    // Need Xiantao's check
-    unsigned char *ept_addr;
-    epte_t *e;
-    struct hax_page *page;
-    struct hax_ept *ept;
-
-    if (hax_vm->ept) {
-        hax_log(HAX_LOGD, "EPT: EPT has been created already!\n");
-        return 0;
-    }
-
-    ept = hax_vmalloc(sizeof(struct hax_ept), 0);
-    if (!ept) {
-        hax_log(HAX_LOGD,
-                "EPT: No enough memory for creating EPT structure!\n");
-        return 0;
-    }
-    memset(ept, 0, sizeof(struct hax_ept));
-    hax_vm->ept = ept;
-
-    page = hax_alloc_pages(EPT_PRE_ALLOC_PG_ORDER, 0, 1);
-    if (!page) {
-        hax_log(HAX_LOGD, "EPT: No enough memory for creating ept table!\n");
-        hax_vfree(hax_vm->ept, sizeof(struct hax_ept));
-        return 0;
-    }
-    ept->ept_root_page = page;
-    ept_addr = hax_page_va(page);
-    memset(ept_addr, 0, EPT_PRE_ALLOC_PAGES * PAGE_SIZE_4K);
-
-    // One page for building PML4 level
-    ept->eptp = ept_construct_eptp(hax_pa(ept_addr));
-    e = (epte_t *)ept_addr;
-
-    // One page for building PDPTE level
-    ept_addr += PAGE_SIZE_4K;
-    hpa = hax_pa(ept_addr);
-    epte_set_entry(e, hpa, 7, EMT_NONE);
-    e = (epte_t *)ept_addr;
-
-    // The rest pages are used to build PDE level
-    for (i = 0; i < EPT_MAX_MEM_G; i++) {
-        ept_addr += PAGE_SIZE_4K;
-        hpa = hax_pa(ept_addr);
-        epte_set_entry(e + i, hpa, 7, EMT_NONE);
-    }
-
-    hax_init_list_head(&ept->ept_page_list);
-
-    hax_log(HAX_LOGI, "ept_init: Calling INVEPT\n");
-    invept(hax_vm, EPT_INVEPT_SINGLE_CONTEXT);
-    return 1;
-}
-
-// Free the whole ept structure
-void ept_free (hax_vm_t *hax_vm)
-{
-    struct hax_page *page, *n;
-    struct hax_ept *ept = hax_vm->ept;
-
-    hax_assert(ept);
-
-    if (!ept->ept_root_page)
-        return;
-
-    hax_log(HAX_LOGI, "ept_free: Calling INVEPT\n");
-    invept(hax_vm, EPT_INVEPT_SINGLE_CONTEXT);
-    hax_list_entry_for_each_safe(page, n, &ept->ept_page_list, struct hax_page,
-                                 list) {
-        hax_list_del(&page->list);
-        hax_free_page(page);
-    }
-
-    hax_free_pages(ept->ept_root_page);
-    hax_vfree(hax_vm->ept, sizeof(struct hax_ept));
-    hax_vm->ept = 0;
-}
-
 struct invept_bundle {
     uint type;
     struct invept_desc *desc;
@@ -416,12 +168,3 @@ void invept(hax_vm_t *hax_vm, uint type)
         }
     }
 }
-
-uint64_t vcpu_get_eptp(struct vcpu_t *vcpu)
-{
-    struct hax_ept *ept = vcpu->vm->ept;
-
-    if (vcpu->mmu->mmu_mode != MMU_MODE_EPT)
-        return INVALID_EPTP;
-    return ept->eptp.val;
-}

core/hax.c

@@ -368,10 +368,8 @@ int hax_get_capability(void *buf, int bufLeng, int *outLength)
         // Fast MMIO supported since API version 2
         cap->winfo = HAX_CAP_FASTMMIO;
         cap->winfo |= HAX_CAP_64BIT_RAMBLOCK;
-#ifdef CONFIG_HAX_EPT2
         cap->winfo |= HAX_CAP_64BIT_SETRAM;
         cap->winfo |= HAX_CAP_IMPLICIT_RAMBLOCK;
-#endif
         cap->winfo |= HAX_CAP_TUNNEL_PAGE;
         cap->winfo |= HAX_CAP_RAM_PROTECTION;
         cap->winfo |= HAX_CAP_DEBUG;