core: Introduce paging_structures abstraction

This structure shall once hold a reference to both the paging hierarchy
and how it is read or manipulated. So far, we once encapsulate the root
table reference and update all sites that deal with page tables.

Signed-off-by: Jan Kiszka <jan.kiszka@siemens.com>

diff --git a/hypervisor/arch/x86/apic.c b/hypervisor/arch/x86/apic.c
index 167a84fce2ba8290f26bbedc7c3136c1f4c15e92..03f75dfa03fb5982c45479baf848c815747dafd9 100644 (file)
--- a/hypervisor/arch/x86/apic.c
+++ b/hypervisor/arch/x86/apic.c
@@ -129,8 +129,8 @@ int apic_init(void)
                xapic_page = page_alloc(&remap_pool, 1);
                if (!xapic_page)
                        return -ENOMEM;
-               err = page_map_create(hv_page_table, XAPIC_BASE, PAGE_SIZE,
-                                     (unsigned long)xapic_page,
+               err = page_map_create(&hv_paging_structs, XAPIC_BASE,
+                                     PAGE_SIZE, (unsigned long)xapic_page,
                                      PAGE_DEFAULT_FLAGS | PAGE_FLAG_UNCACHED,
                                      PAGE_DEFAULT_FLAGS, PAGE_DIR_LEVELS,
                                      PAGE_MAP_NON_COHERENT);

diff --git a/hypervisor/arch/x86/include/asm/cell.h b/hypervisor/arch/x86/include/asm/cell.h
index 8c95a0c82c534ec34243f600d7ec812254a92d5b..e490acdf8cc54ae1e06ee09bf9d3ebdcbfb583f3 100644 (file)
--- a/hypervisor/arch/x86/include/asm/cell.h
+++ b/hypervisor/arch/x86/include/asm/cell.h
@@ -13,8 +13,7 @@
 #ifndef _JAILHOUSE_ASM_CELL_H
 #define _JAILHOUSE_ASM_CELL_H
 
-#include <asm/types.h>
-#include <asm/paging.h>
+#include <jailhouse/paging.h>
 
 #include <jailhouse/cell-config.h>
 #include <jailhouse/hypercall.h>
@@ -23,11 +22,11 @@ struct cell {
        struct {
                /* should be first as it requires page alignment */
                u8 __attribute__((aligned(PAGE_SIZE))) io_bitmap[2*PAGE_SIZE];
-               pgd_t *ept;
+               struct paging_structures ept_structs;
        } vmx;
 
        struct {
-               pgd_t *page_table;
+               struct paging_structures pg_structs;
        } vtd;
 
        unsigned int id;

diff --git a/hypervisor/arch/x86/setup.c b/hypervisor/arch/x86/setup.c
index bcfa86a5e4c0c6844bf5b9c15a3659f8da20a8da..408650b4a49d8ee585cecd527e9ee25ece95264b 100644 (file)
--- a/hypervisor/arch/x86/setup.c
+++ b/hypervisor/arch/x86/setup.c
@@ -162,7 +162,7 @@ int arch_cpu_init(struct per_cpu *cpu_data)
 
        /* swap CR3 */
        cpu_data->linux_cr3 = read_cr3();
-       write_cr3(page_map_hvirt2phys(hv_page_table));
+       write_cr3(page_map_hvirt2phys(hv_paging_structs.root_table));
 
        /* set GDTR */
        dtr.limit = NUM_GDT_DESC * 8 - 1;

diff --git a/hypervisor/arch/x86/vmx.c b/hypervisor/arch/x86/vmx.c
index 1a58b13fe39cdb82a5bb622a20b708fad85216a7..1002fdb04eef2b0d15136ef4749ffe7938ad3213 100644 (file)
--- a/hypervisor/arch/x86/vmx.c
+++ b/hypervisor/arch/x86/vmx.c
@@ -176,7 +176,7 @@ int vmx_map_memory_region(struct cell *cell,
                phys_start = page_map_hvirt2phys(&cell->comm_page);
        table_flags = page_flags & ~EPT_FLAG_WB_TYPE;
 
-       return page_map_create(cell->vmx.ept, phys_start, mem->size,
+       return page_map_create(&cell->vmx.ept_structs, phys_start, mem->size,
                               mem->virt_start, page_flags, table_flags,
                               PAGE_DIR_LEVELS, PAGE_MAP_NON_COHERENT);
 }
@@ -184,14 +184,14 @@ int vmx_map_memory_region(struct cell *cell,
 void vmx_unmap_memory_region(struct cell *cell,
                             const struct jailhouse_memory *mem)
 {
-       page_map_destroy(cell->vmx.ept, mem->virt_start, mem->size,
+       page_map_destroy(&cell->vmx.ept_structs, mem->virt_start, mem->size,
                         PAGE_DIR_LEVELS, PAGE_MAP_NON_COHERENT);
 }
 
 unsigned long arch_page_map_gphys2phys(struct per_cpu *cpu_data,
                                       unsigned long gphys)
 {
-       return page_map_virt2phys(cpu_data->cell->vmx.ept, gphys,
+       return page_map_virt2phys(&cpu_data->cell->vmx.ept_structs, gphys,
                                  PAGE_DIR_LEVELS);
 }
 
@@ -206,25 +206,25 @@ int vmx_cell_init(struct cell *cell)
        u32 size;
 
        /* build root cell EPT */
-       cell->vmx.ept = page_alloc(&mem_pool, 1);
-       if (!cell->vmx.ept)
+       cell->vmx.ept_structs.root_table = page_alloc(&mem_pool, 1);
+       if (!cell->vmx.ept_structs.root_table)
                return -ENOMEM;
 
        for (n = 0; n < config->num_memory_regions; n++, mem++) {
                err = vmx_map_memory_region(cell, mem);
                if (err)
-                       /* FIXME: release vmx.ept */
+                       /* FIXME: release vmx.ept_structs.root_table */
                        return err;
        }
 
-       err = page_map_create(cell->vmx.ept,
+       err = page_map_create(&cell->vmx.ept_structs,
                              page_map_hvirt2phys(apic_access_page),
                              PAGE_SIZE, XAPIC_BASE,
                              EPT_FLAG_READ|EPT_FLAG_WRITE|EPT_FLAG_WB_TYPE,
                              EPT_FLAG_READ|EPT_FLAG_WRITE,
                              PAGE_DIR_LEVELS, PAGE_MAP_NON_COHERENT);
        if (err)
-               /* FIXME: release vmx.ept */
+               /* FIXME: release vmx.ept_structs.root_table */
                return err;
 
        memset(cell->vmx.io_bitmap, -1, sizeof(cell->vmx.io_bitmap));
@@ -251,8 +251,9 @@ void vmx_linux_cell_shrink(struct jailhouse_cell_desc *config)
 
        for (n = 0; n < config->num_memory_regions; n++, mem++)
                if (!(mem->flags & JAILHOUSE_MEM_COMM_REGION))
-                       page_map_destroy(linux_cell.vmx.ept, mem->phys_start,
-                                        mem->size, PAGE_DIR_LEVELS,
+                       page_map_destroy(&linux_cell.vmx.ept_structs,
+                                        mem->phys_start, mem->size,
+                                        PAGE_DIR_LEVELS,
                                         PAGE_MAP_NON_COHERENT);
 
        for (b = linux_cell.vmx.io_bitmap; pio_bitmap_size > 0;
@@ -271,7 +272,7 @@ void vmx_cell_exit(struct cell *cell)
        u32 pio_bitmap_size = config->pio_bitmap_size;
        u8 *b;
 
-       page_map_destroy(cell->vmx.ept, XAPIC_BASE, PAGE_SIZE,
+       page_map_destroy(&cell->vmx.ept_structs, XAPIC_BASE, PAGE_SIZE,
                         PAGE_DIR_LEVELS, PAGE_MAP_NON_COHERENT);
 
        if (linux_cell.config->pio_bitmap_size < pio_bitmap_size)
@@ -281,7 +282,7 @@ void vmx_cell_exit(struct cell *cell)
             b++, pio_bitmap++, linux_pio_bitmap++, pio_bitmap_size--)
                *b &= *pio_bitmap | *linux_pio_bitmap;
 
-       page_free(&mem_pool, cell->vmx.ept, 1);
+       page_free(&mem_pool, cell->vmx.ept_structs.root_table, 1);
 }
 
 void vmx_invept(void)
@@ -354,8 +355,8 @@ static bool vmx_set_cell_config(struct cell *cell)
                           page_map_hvirt2phys(io_bitmap + PAGE_SIZE));
 
        ok &= vmcs_write64(EPT_POINTER,
-                          page_map_hvirt2phys(cell->vmx.ept) |
-                          EPT_TYPE_WRITEBACK | EPT_PAGE_WALK_LEN);
+                       page_map_hvirt2phys(cell->vmx.ept_structs.root_table) |
+                       EPT_TYPE_WRITEBACK | EPT_PAGE_WALK_LEN);
 
        return ok;
 }

diff --git a/hypervisor/arch/x86/vtd.c b/hypervisor/arch/x86/vtd.c
index 30eb1dde3a26b56d83d361f9a10dd89756266808..e06a60d63870b1e55ce668c9a7cfc20c8d34f2c2 100644 (file)
--- a/hypervisor/arch/x86/vtd.c
+++ b/hypervisor/arch/x86/vtd.c
@@ -105,8 +105,9 @@ int vtd_init(void)
                else if (reg_base != dmar_reg_base + dmar_units * PAGE_SIZE)
                        return -ENOMEM;
 
-               err = page_map_create(hv_page_table, drhd->register_base_addr,
-                                     PAGE_SIZE, (unsigned long)reg_base,
+               err = page_map_create(&hv_paging_structs,
+                                     drhd->register_base_addr, PAGE_SIZE,
+                                     (unsigned long)reg_base,
                                      PAGE_DEFAULT_FLAGS | PAGE_FLAG_UNCACHED,
                                      PAGE_DEFAULT_FLAGS, PAGE_DIR_LEVELS,
                                      PAGE_MAP_NON_COHERENT);
@@ -176,7 +177,7 @@ static bool vtd_add_device_to_cell(struct cell *cell,
        context_entry = &context_entry_table[device->devfn];
        context_entry->lo_word = VTD_CTX_PRESENT |
                VTD_CTX_FPD | VTD_CTX_TTYPE_MLP_UNTRANS |
-               page_map_hvirt2phys(cell->vtd.page_table);
+               page_map_hvirt2phys(cell->vtd.pg_structs.root_table);
        context_entry->hi_word =
                (dmar_pt_levels == 3 ? VTD_CTX_AGAW_39 : VTD_CTX_AGAW_48) |
                (cell->id << VTD_CTX_DID_SHIFT);
@@ -202,20 +203,20 @@ int vtd_cell_init(struct cell *cell)
        if (cell->id >= dmar_num_did)
                return -ERANGE;
 
-       cell->vtd.page_table = page_alloc(&mem_pool, 1);
-       if (!cell->vtd.page_table)
+       cell->vtd.pg_structs.root_table = page_alloc(&mem_pool, 1);
+       if (!cell->vtd.pg_structs.root_table)
                return -ENOMEM;
 
        for (n = 0; n < config->num_memory_regions; n++, mem++) {
                err = vtd_map_memory_region(cell, mem);
                if (err)
-                       /* FIXME: release vtd.page_table */
+                       /* FIXME: release vtd.pg_structs.root_table */
                        return err;
        }
 
        for (n = 0; n < config->num_pci_devices; n++)
                if (!vtd_add_device_to_cell(cell, &dev[n]))
-                       /* FIXME: release vtd.page_table,
+                       /* FIXME: release vtd.pg_structs.root_table,
                         * revert device additions*/
                        return -ENOMEM;
 
@@ -279,7 +280,7 @@ void vtd_linux_cell_shrink(struct jailhouse_cell_desc *config)
 
        for (n = 0; n < config->num_memory_regions; n++, mem++)
                if (mem->flags & JAILHOUSE_MEM_DMA)
-                       page_map_destroy(linux_cell.vtd.page_table,
+                       page_map_destroy(&linux_cell.vtd.pg_structs,
                                         mem->phys_start, mem->size,
                                         dmar_pt_levels, PAGE_MAP_COHERENT);
 
@@ -306,7 +307,7 @@ int vtd_map_memory_region(struct cell *cell,
        if (mem->flags & JAILHOUSE_MEM_WRITE)
                page_flags |= VTD_PAGE_WRITE;
 
-       return page_map_create(cell->vtd.page_table, mem->phys_start,
+       return page_map_create(&cell->vtd.pg_structs, mem->phys_start,
                               mem->size, mem->virt_start, page_flags,
                               VTD_PAGE_READ | VTD_PAGE_WRITE,
                               dmar_pt_levels, PAGE_MAP_COHERENT);
@@ -320,7 +321,7 @@ void vtd_unmap_memory_region(struct cell *cell,
                return;
 
        if (mem->flags & JAILHOUSE_MEM_DMA)
-               page_map_destroy(cell->vtd.page_table, mem->virt_start,
+               page_map_destroy(&cell->vtd.pg_structs, mem->virt_start,
                                 mem->size, dmar_pt_levels, PAGE_MAP_COHERENT);
 }
 
@@ -355,7 +356,7 @@ void vtd_cell_exit(struct cell *cell)
        vtd_flush_domain_caches(cell->id);
        vtd_flush_domain_caches(linux_cell.id);
 
-       page_free(&mem_pool, cell->vtd.page_table, 1);
+       page_free(&mem_pool, cell->vtd.pg_structs.root_table, 1);
 }
 
 void vtd_shutdown(void)

diff --git a/hypervisor/control.c b/hypervisor/control.c
index c5cdc682358d71163868eb9f791a82d66d3d47d4..0622800a132428a2fa8e557b0f33613f9b7cd760 100644 (file)
--- a/hypervisor/control.c
+++ b/hypervisor/control.c
@@ -147,7 +147,7 @@ int cell_create(struct per_cpu *cpu_data, unsigned long config_address)
        cfg_header_size = (config_address & ~PAGE_MASK) +
                sizeof(struct jailhouse_cell_desc);
 
-       err = page_map_create(hv_page_table, config_address & PAGE_MASK,
+       err = page_map_create(&hv_paging_structs, config_address & PAGE_MASK,
                              cfg_header_size, mapping_addr,
                              PAGE_READONLY_FLAGS, PAGE_DEFAULT_FLAGS,
                              PAGE_DIR_LEVELS, PAGE_MAP_NON_COHERENT);
@@ -167,7 +167,7 @@ int cell_create(struct per_cpu *cpu_data, unsigned long config_address)
                goto resume_out;
        }
 
-       err = page_map_create(hv_page_table, config_address & PAGE_MASK,
+       err = page_map_create(&hv_paging_structs, config_address & PAGE_MASK,
                              cfg_total_size, mapping_addr,
                              PAGE_READONLY_FLAGS, PAGE_DEFAULT_FLAGS,
                              PAGE_DIR_LEVELS, PAGE_MAP_NON_COHERENT);
@@ -332,7 +332,7 @@ int cell_destroy(struct per_cpu *cpu_data, unsigned long name_address)
 
        name_size = (name_address & ~PAGE_MASK) + JAILHOUSE_CELL_NAME_MAXLEN;
 
-       err = page_map_create(hv_page_table, name_address & PAGE_MASK,
+       err = page_map_create(&hv_paging_structs, name_address & PAGE_MASK,
                              name_size, mapping_addr, PAGE_READONLY_FLAGS,
                              PAGE_DEFAULT_FLAGS, PAGE_DIR_LEVELS,
                              PAGE_MAP_NON_COHERENT);

diff --git a/hypervisor/include/jailhouse/paging.h b/hypervisor/include/jailhouse/paging.h
index 388d50c1bb10f946595971cd105652611ca88b70..6898b859387aed03f9734dfc331f7304c3d297c2 100644 (file)
--- a/hypervisor/include/jailhouse/paging.h
+++ b/hypervisor/include/jailhouse/paging.h
@@ -10,6 +10,9 @@
  * the COPYING file in the top-level directory.
  */
 
+#ifndef _JAILHOUSE_PAGING_H
+#define _JAILHOUSE_PAGING_H
+
 #include <jailhouse/entry.h>
 #include <asm/types.h>
 #include <asm/paging.h>
@@ -34,10 +37,16 @@ enum page_map_coherent {
        PAGE_MAP_NON_COHERENT,
 };
 
+typedef pgd_t *page_table_t;
+
+struct paging_structures {
+       page_table_t root_table;
+};
+
 extern struct page_pool mem_pool;
 extern struct page_pool remap_pool;
 
-extern pgd_t *hv_page_table;
+extern struct paging_structures hv_paging_structs;
 
 void *page_alloc(struct page_pool *pool, unsigned int num);
 void page_free(struct page_pool *pool, void *first_page, unsigned int num);
@@ -52,19 +61,19 @@ static inline void *page_map_phys2hvirt(unsigned long phys)
        return (void *)phys + hypervisor_header.page_offset;
 }
 
-unsigned long page_map_virt2phys(pgd_t *page_table, unsigned long virt,
-                                unsigned int levels);
+unsigned long page_map_virt2phys(const struct paging_structures *pg_structs,
+                                unsigned long virt, unsigned int levels);
 
 unsigned long arch_page_map_gphys2phys(struct per_cpu *cpu_data,
                                       unsigned long gphys);
 
-int page_map_create(pgd_t *page_table, unsigned long phys, unsigned long size,
-                   unsigned long virt, unsigned long page_flags,
-                   unsigned long table_flags, unsigned int levels,
-                   enum page_map_coherent coherent);
-void page_map_destroy(pgd_t *page_table, unsigned long virt,
-                     unsigned long size, unsigned int levels,
-                     enum page_map_coherent coherent);
+int page_map_create(const struct paging_structures *pg_structs,
+                   unsigned long phys, unsigned long size, unsigned long virt,
+                   unsigned long flags, unsigned long table_flags,
+                   unsigned int levels, enum page_map_coherent coherent);
+void page_map_destroy(const struct paging_structures *pg_structs,
+                     unsigned long virt, unsigned long size,
+                     unsigned int levels, enum page_map_coherent coherent);
 
 void *page_map_get_guest_page(struct per_cpu *cpu_data,
                              unsigned long page_table_paddr,
@@ -72,3 +81,5 @@ void *page_map_get_guest_page(struct per_cpu *cpu_data,
 
 int paging_init(void);
 void page_map_dump_stats(const char *when);
+
+#endif /* !_JAILHOUSE_PAGING_H */

diff --git a/hypervisor/paging.c b/hypervisor/paging.c
index 3bb677a6f1437e699a9cc681a321f296ccea21cd..4b67812420159df2b36f6bbc39dcef153ebfea4c 100644 (file)
--- a/hypervisor/paging.c
+++ b/hypervisor/paging.c
@@ -30,7 +30,7 @@ struct page_pool remap_pool = {
        .pages = BITS_PER_PAGE * NUM_REMAP_BITMAP_PAGES,
 };
 
-pgd_t *hv_page_table;
+struct paging_structures hv_paging_structs;
 
 static unsigned long find_next_free_page(struct page_pool *pool,
                                         unsigned long start)
@@ -103,8 +103,8 @@ void page_free(struct page_pool *pool, void *page, unsigned int num)
        }
 }
 
-unsigned long page_map_virt2phys(pgd_t *page_table, unsigned long virt,
-                                unsigned int levels)
+unsigned long page_map_virt2phys(const struct paging_structures *pg_structs,
+                                unsigned long virt, unsigned int levels)
 {
        unsigned long offs = hypervisor_header.page_offset;
        pgd_t *pgd;
@@ -114,14 +114,14 @@ unsigned long page_map_virt2phys(pgd_t *page_table, unsigned long virt,
 
        switch (levels) {
        case 4:
-               pgd = pgd_offset(page_table, virt);
+               pgd = pgd_offset(pg_structs->root_table, virt);
                if (!pgd_valid(pgd))
                        return INVALID_PHYS_ADDR;
 
                pud = pud4l_offset(pgd, offs, virt);
                break;
        case 3:
-               pud = pud3l_offset(page_table, virt);
+               pud = pud3l_offset(pg_structs->root_table, virt);
                break;
        default:
                return INVALID_PHYS_ADDR;
@@ -150,10 +150,10 @@ static void flush_page_table(void *addr, unsigned long size,
                flush_cache(addr, size);
 }
 
-int page_map_create(pgd_t *page_table, unsigned long phys, unsigned long size,
-                   unsigned long virt, unsigned long flags,
-                   unsigned long table_flags, unsigned int levels,
-                   enum page_map_coherent coherent)
+int page_map_create(const struct paging_structures *pg_structs,
+                   unsigned long phys, unsigned long size, unsigned long virt,
+                   unsigned long flags, unsigned long table_flags,
+                   unsigned int levels, enum page_map_coherent coherent)
 {
        unsigned long offs = hypervisor_header.page_offset;
        pgd_t *pgd;
@@ -165,7 +165,7 @@ int page_map_create(pgd_t *page_table, unsigned long phys, unsigned long size,
             phys += PAGE_SIZE, virt += PAGE_SIZE, size -= PAGE_SIZE) {
                switch (levels) {
                case 4:
-                       pgd = pgd_offset(page_table, virt);
+                       pgd = pgd_offset(pg_structs->root_table, virt);
                        if (!pgd_valid(pgd)) {
                                pud = page_alloc(&mem_pool, 1);
                                if (!pud)
@@ -177,7 +177,7 @@ int page_map_create(pgd_t *page_table, unsigned long phys, unsigned long size,
                        pud = pud4l_offset(pgd, offs, virt);
                        break;
                case 3:
-                       pud = pud3l_offset(page_table, virt);
+                       pud = pud3l_offset(pg_structs->root_table, virt);
                        break;
                default:
                        return -EINVAL;
@@ -209,9 +209,9 @@ int page_map_create(pgd_t *page_table, unsigned long phys, unsigned long size,
        return 0;
 }
 
-void page_map_destroy(pgd_t *page_table, unsigned long virt,
-                     unsigned long size, unsigned int levels,
-                     enum page_map_coherent coherent)
+void page_map_destroy(const struct paging_structures *pg_structs,
+                     unsigned long virt, unsigned long size,
+                     unsigned int levels, enum page_map_coherent coherent)
 {
        unsigned long offs = hypervisor_header.page_offset;
        pgd_t *pgd;
@@ -223,7 +223,7 @@ void page_map_destroy(pgd_t *page_table, unsigned long virt,
             virt += PAGE_SIZE, size -= PAGE_SIZE) {
                switch (levels) {
                case 4:
-                       pgd = pgd_offset(page_table, virt);
+                       pgd = pgd_offset(pg_structs->root_table, virt);
                        if (!pgd_valid(pgd))
                                continue;
 
@@ -231,7 +231,7 @@ void page_map_destroy(pgd_t *page_table, unsigned long virt,
                        break;
                case 3:
                        pgd = 0; /* silence compiler warning */
-                       pud = pud3l_offset(page_table, virt);
+                       pud = pud3l_offset(pg_structs->root_table, virt);
                        break;
                default:
                        return;
@@ -286,7 +286,7 @@ void *page_map_get_guest_page(struct per_cpu *cpu_data,
        phys = arch_page_map_gphys2phys(cpu_data, page_table_paddr);
        if (phys == INVALID_PHYS_ADDR)
                return NULL;
-       err = page_map_create(hv_page_table, phys, PAGE_SIZE, page_virt,
+       err = page_map_create(&hv_paging_structs, phys, PAGE_SIZE, page_virt,
                              PAGE_READONLY_FLAGS, PAGE_DEFAULT_FLAGS,
                              PAGE_DIR_LEVELS, PAGE_MAP_NON_COHERENT);
        if (err)
@@ -300,7 +300,7 @@ void *page_map_get_guest_page(struct per_cpu *cpu_data,
                        (unsigned long)pud4l_offset(pgd, 0, 0));
        if (phys == INVALID_PHYS_ADDR)
                return NULL;
-       err = page_map_create(hv_page_table, phys, PAGE_SIZE, page_virt,
+       err = page_map_create(&hv_paging_structs, phys, PAGE_SIZE, page_virt,
                              PAGE_READONLY_FLAGS, PAGE_DEFAULT_FLAGS,
                              PAGE_DIR_LEVELS, PAGE_MAP_NON_COHERENT);
        if (err)
@@ -318,7 +318,7 @@ void *page_map_get_guest_page(struct per_cpu *cpu_data,
                                        (unsigned long)pmd_offset(pud, 0, 0));
        if (phys == INVALID_PHYS_ADDR)
                return NULL;
-       err = page_map_create(hv_page_table, phys, PAGE_SIZE, page_virt,
+       err = page_map_create(&hv_paging_structs, phys, PAGE_SIZE, page_virt,
                              PAGE_READONLY_FLAGS, PAGE_DEFAULT_FLAGS,
                              PAGE_DIR_LEVELS, PAGE_MAP_NON_COHERENT);
        if (err)
@@ -334,7 +334,7 @@ void *page_map_get_guest_page(struct per_cpu *cpu_data,
                                (unsigned long)pte_offset(pmd, 0, 0));
                if (phys == INVALID_PHYS_ADDR)
                        return NULL;
-               err = page_map_create(hv_page_table, phys, PAGE_SIZE,
+               err = page_map_create(&hv_paging_structs, phys, PAGE_SIZE,
                                      page_virt, PAGE_READONLY_FLAGS,
                                      PAGE_DEFAULT_FLAGS, PAGE_DIR_LEVELS,
                                      PAGE_MAP_NON_COHERENT);
@@ -350,7 +350,7 @@ void *page_map_get_guest_page(struct per_cpu *cpu_data,
        if (phys == INVALID_PHYS_ADDR)
                return NULL;
 
-       err = page_map_create(hv_page_table, phys, PAGE_SIZE, page_virt,
+       err = page_map_create(&hv_paging_structs, phys, PAGE_SIZE, page_virt,
                              flags, PAGE_DEFAULT_FLAGS, PAGE_DIR_LEVELS,
                              PAGE_MAP_NON_COHERENT);
        if (err)
@@ -394,12 +394,12 @@ int paging_init(void)
        for (n = 0; n < remap_pool.used_pages; n++)
                set_bit(n, remap_pool.used_bitmap);
 
-       hv_page_table = page_alloc(&mem_pool, 1);
-       if (!hv_page_table)
+       hv_paging_structs.root_table = page_alloc(&mem_pool, 1);
+       if (!hv_paging_structs.root_table)
                goto error_nomem;
 
        /* Replicate hypervisor mapping of Linux */
-       err = page_map_create(hv_page_table,
+       err = page_map_create(&hv_paging_structs,
                              page_map_hvirt2phys(&hypervisor_header),
                              hypervisor_header.size,
                              (unsigned long)&hypervisor_header,
@@ -410,7 +410,7 @@ int paging_init(void)
 
        /* Make sure any remappings to the temporary regions can be performed
         * without allocations of page table pages. */
-       err = page_map_create(hv_page_table, 0,
+       err = page_map_create(&hv_paging_structs, 0,
                              remap_pool.used_pages * PAGE_SIZE,
                              TEMPORARY_MAPPING_BASE, PAGE_NONPRESENT_FLAGS,
                              PAGE_DEFAULT_FLAGS, PAGE_DIR_LEVELS,

diff --git a/hypervisor/setup.c b/hypervisor/setup.c
index 65261a27e5ba7940a1d58b02c44026032a142eec..eb01d55d2d24916b5a037ce04e949a654ae0e9c7 100644 (file)
--- a/hypervisor/setup.c
+++ b/hypervisor/setup.c
@@ -72,7 +72,7 @@ static void init_early(unsigned int cpu_id)
                        return;
                }
 
-               error = page_map_create(hv_page_table,
+               error = page_map_create(&hv_paging_structs,
                                system_config->config_memory.phys_start,
                                size, (unsigned long)config_memory,
                                PAGE_READONLY_FLAGS, PAGE_DEFAULT_FLAGS,