core: Rename jailhouse_memory::access_flags to flags

We will encode more than access types in them. No functional changes.

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

diff --git a/configs/apic-demo.c b/configs/apic-demo.c
index 5df4ccfd5648e7b2c12cc9a9e9e08240d63b837b..2e49a000b39e44d336ac574782efc0f6780aa24a 100644 (file)
--- a/configs/apic-demo.c
+++ b/configs/apic-demo.c
@@ -43,8 +43,8 @@ struct {
                        .phys_start = 0x3bf00000,
                        .virt_start = 0,
                        .size = 0x00100000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE,
                },
        },
 

diff --git a/configs/celsius-w420.c b/configs/celsius-w420.c
index 7f242629e55f8896d9acfe02b36d87a9b07132a2..9549a7e43d942b3e712fe77849e084979211670c 100644 (file)
--- a/configs/celsius-w420.c
+++ b/configs/celsius-w420.c
@@ -56,102 +56,90 @@ struct {
                        .phys_start = 0x0,
                        .virt_start = 0x0,
                        .size = 0x1bf00000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* RAM */ {
                        .phys_start = 0x1ff00000,
                        .virt_start = 0x1ff00000,
                        .size = 0x100000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* RAM */ {
                        .phys_start = 0x20200000,
                        .virt_start = 0x20200000,
                        .size = 0x1fe04000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* RAM */ {
                        .phys_start = 0x40005000,
                        .virt_start = 0x40005000,
                        .size = 0x97f3c000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* ACPI */ {
                        .phys_start = 0xd8a2a000,
                        .virt_start = 0xd8a2a000,
                        .size = 0x11e000,
-                       .access_flags = JAILHOUSE_MEM_READ,
+                       .flags = JAILHOUSE_MEM_READ,
                },
                /* RAM */ {
                        .phys_start = 0xda382000,
                        .virt_start = 0xda382000,
                        .size = 0x1000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* ACPI */ {
                        .phys_start = 0xda383000,
                        .virt_start = 0xda383000,
                        .size = 0x43000,
-                       .access_flags = JAILHOUSE_MEM_READ,
+                       .flags = JAILHOUSE_MEM_READ,
                },
                /* RAM */ {
                        .phys_start = 0xda3c6000,
                        .virt_start = 0xda3c6000,
                        .size = 0x9df000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* RAM */ {
                        .phys_start = 0xdafef000,
                        .virt_start = 0xdafef000,
                        .size = 0x11000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* PCI */ {
                        .phys_start = 0xdfa00000,
                        .virt_start = 0xdfa00000,
                        .size = 0x1f100000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE,
                },
                /* yeah, that's not really safe... */
                /* IOAPIC */ {
                        .phys_start = 0xfec00000,
                        .virt_start = 0xfec00000,
                        .size = 0x1000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE,
                },
                /* the same here until we catch MSIs via interrupt remapping */
                /* HPET */ {
                        .phys_start = 0xfed00000,
                        .virt_start = 0xfed00000,
                        .size = 0x1000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE,
                },
                /* RAM */ {
                        .phys_start = 0x100000000,
                        .virt_start = 0x100000000,
                        .size = 0x1e600000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
-
        },
 
        .pio_bitmap = {

diff --git a/configs/chromebook.c b/configs/chromebook.c
index 40968dc5ae467e32059636feabecd3d41f295685..c264b300ad0780cccc0e459f6ef221a366854890 100644 (file)
--- a/configs/chromebook.c
+++ b/configs/chromebook.c
@@ -49,8 +49,8 @@ struct {
                        .phys_start = 0x0,
                        .virt_start = 0x0,
                        .size = 0x3c000000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE,
                },
        },
 };

diff --git a/configs/h700-8G.c b/configs/h700-8G.c
index 8ae55c0d8dc0dabec22f9c87a28bdc2ba322caaf..23ec03b4355b29d45eb2ede14415ea7c2694131c 100644 (file)
--- a/configs/h700-8G.c
+++ b/configs/h700-8G.c
@@ -54,70 +54,62 @@ struct {
                        .phys_start = 0x0,
                        .virt_start = 0x0,
                        .size = 0x3c000000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* RAM */ {
                        .phys_start = 0x40000000,
                        .virt_start = 0x40000000,
                        .size = 0x7f7de000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* ACPI */ {
                        .phys_start = 0xbf7de000,
                        .virt_start = 0xbf7de000,
                        .size = 0x21000,
-                       .access_flags = JAILHOUSE_MEM_READ,
+                       .flags = JAILHOUSE_MEM_READ,
                },
                /* RAM */ {
                        .phys_start = 0xbf7ff000,
                        .virt_start = 0xbf7ff000,
                        .size = 0x801000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* PCI */ {
                        .phys_start = 0xc0000000,
                        .virt_start = 0xc0000000,
                        .size = 0x3eb00000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE,
                },
                /* yeah, that's not really safe... */
                /* IOAPIC */ {
                        .phys_start = 0xfec00000,
                        .virt_start = 0xfec00000,
                        .size = 0x1000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE,
                },
                /* the same here until we catch MSIs via interrupt remapping */
                /* HPET */ {
                        .phys_start = 0xfed00000,
                        .virt_start = 0xfed00000,
                        .size = 0x1000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE,
                },
                /* RAM */ {
                        .phys_start = 0x100000000,
                        .virt_start = 0x100000000,
                        .size = 0xfc000000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* RAM */ {
                        .phys_start = 0x200000000,
                        .virt_start = 0x200000000,
                        .size = 0x3c000000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
        },
 

diff --git a/configs/h87i.c b/configs/h87i.c
index a8f8215a01fd0669785c205e30ce111a33379b23..19675654040719311325a424cb4a3feda1cabc55 100644 (file)
--- a/configs/h87i.c
+++ b/configs/h87i.c
@@ -54,70 +54,62 @@ struct {
                        .phys_start = 0x0,
                        .virt_start = 0x0,
                        .size = 0x3c000000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* RAM */ {
                        .phys_start = 0x40000000,
                        .virt_start = 0x40000000,
                        .size = 0x8ca64000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* ACPI */ {
                        .phys_start = 0xcca64000,
                        .virt_start = 0xcca64000,
                        .size = 0x15000,
-                       .access_flags = JAILHOUSE_MEM_READ,
+                       .flags = JAILHOUSE_MEM_READ,
                },
                /* RAM */ {
                        .phys_start = 0xcca79000,
                        .virt_start = 0xcca79000,
                        .size = 0x12787000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* RAM */ {
                        .phys_start = 0xcf200000,
                        .virt_start = 0xcf200000,
                        .size = 0x10000000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* PCI */ {
                        .phys_start = 0xdf200000,
                        .virt_start = 0xdf200000,
                        .size = 0x1fa00000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE,
                },
                /* yeah, that's not really safe... */
                /* IOAPIC */ {
                        .phys_start = 0xfec00000,
                        .virt_start = 0xfec00000,
                        .size = 0x1000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE,
                },
                /* the same here until we catch MSIs via interrupt remapping */
                /* HPET */ {
                        .phys_start = 0xfed00000,
                        .virt_start = 0xfed00000,
                        .size = 0x1000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE,
                },
                /* RAM */ {
                        .phys_start = 0x100000000,
                        .virt_start = 0x100000000,
                        .size = 0x20000000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
        },
 

diff --git a/configs/qemu-vm.c b/configs/qemu-vm.c
index e0d5b427f587a8126ec35912a87e3631a423ffc3..b835d2e70865e0f23443144b725dd89b69a6c876 100644 (file)
--- a/configs/qemu-vm.c
+++ b/configs/qemu-vm.c
@@ -44,7 +44,6 @@ struct {
                        .num_memory_regions = ARRAY_SIZE(config.mem_regions),
                        .num_irq_lines = 0,
                        .pio_bitmap_size = ARRAY_SIZE(config.pio_bitmap),
-
                        .num_pci_devices = 0,
                },
        },
@@ -58,38 +57,34 @@ struct {
                        .phys_start = 0x0,
                        .virt_start = 0x0,
                        .size = 0x3c000000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE |
-                               JAILHOUSE_MEM_DMA,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA,
                },
                /* ACPI */ {
                        .phys_start = 0x3fffe000,
                        .virt_start = 0x3fffe000,
                        .size = 0x2000,
-                       .access_flags = JAILHOUSE_MEM_READ,
+                       .flags = JAILHOUSE_MEM_READ,
                },
                /* PCI */ {
                        .phys_start = 0x80000000,
                        .virt_start = 0x80000000,
                        .size = 0x7ec00000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE,
                },
                /* yeah, that's not really safe... */
                /* IOAPIC */ {
                        .phys_start = 0xfec00000,
                        .virt_start = 0xfec00000,
                        .size = 0x1000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE,
                },
                /* the same here until we catch MSIs via interrupt remapping */
                /* HPET */ {
                        .phys_start = 0xfed00000,
                        .virt_start = 0xfed00000,
                        .size = 0x1000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE,
                },
        },
 

diff --git a/configs/tiny-demo.c b/configs/tiny-demo.c
index e6a294475d6d7818086a425220e40dc2bdc498a6..69929873517c235753aae29cf9b02981eba58c70 100644 (file)
--- a/configs/tiny-demo.c
+++ b/configs/tiny-demo.c
@@ -43,8 +43,8 @@ struct {
                        .phys_start = 0x3be00000,
                        .virt_start = 0,
                        .size = 0x00100000,
-                       .access_flags = JAILHOUSE_MEM_READ |
-                               JAILHOUSE_MEM_WRITE | JAILHOUSE_MEM_EXECUTE,
+                       .flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
+                               JAILHOUSE_MEM_EXECUTE,
                },
        },
 

diff --git a/hypervisor/arch/x86/vmx.c b/hypervisor/arch/x86/vmx.c
index a1ae3f6d458d367e53d09347ebde327f6a24d312..22e16f7ab5b861413bc552f54e374efcd4204a3a 100644 (file)
--- a/hypervisor/arch/x86/vmx.c
+++ b/hypervisor/arch/x86/vmx.c
@@ -165,11 +165,11 @@ int vmx_map_memory_region(struct cell *cell,
 {
        u32 table_flags, page_flags = EPT_FLAG_WB_TYPE;
 
-       if (mem->access_flags & JAILHOUSE_MEM_READ)
+       if (mem->flags & JAILHOUSE_MEM_READ)
                page_flags |= EPT_FLAG_READ;
-       if (mem->access_flags & JAILHOUSE_MEM_WRITE)
+       if (mem->flags & JAILHOUSE_MEM_WRITE)
                page_flags |= EPT_FLAG_WRITE;
-       if (mem->access_flags & JAILHOUSE_MEM_EXECUTE)
+       if (mem->flags & JAILHOUSE_MEM_EXECUTE)
                page_flags |= EPT_FLAG_EXECUTE;
        table_flags = page_flags & ~EPT_FLAG_WB_TYPE;
 

diff --git a/hypervisor/arch/x86/vtd.c b/hypervisor/arch/x86/vtd.c
index 1b73b5ff5114b046e03e5dc49ec669e4aa0d4cd2..f4cbe15ce850172a8d3355fd8eb56b8e3b8e6b50 100644 (file)
--- a/hypervisor/arch/x86/vtd.c
+++ b/hypervisor/arch/x86/vtd.c
@@ -275,7 +275,7 @@ void vtd_linux_cell_shrink(struct jailhouse_cell_desc *config)
        unsigned int n;
 
        for (n = 0; n < config->num_memory_regions; n++, mem++)
-               if (mem->access_flags & JAILHOUSE_MEM_DMA)
+               if (mem->flags & JAILHOUSE_MEM_DMA)
                        page_map_destroy(linux_cell.vtd.page_table,
                                         mem->phys_start, mem->size,
                                         dmar_pt_levels, PAGE_MAP_COHERENT);
@@ -295,12 +295,12 @@ int vtd_map_memory_region(struct cell *cell,
        if (dmar_units == 0)
                return 0;
 
-       if (!(mem->access_flags & JAILHOUSE_MEM_DMA))
+       if (!(mem->flags & JAILHOUSE_MEM_DMA))
                return 0;
 
-       if (mem->access_flags & JAILHOUSE_MEM_READ)
+       if (mem->flags & JAILHOUSE_MEM_READ)
                page_flags |= VTD_PAGE_READ;
-       if (mem->access_flags & JAILHOUSE_MEM_WRITE)
+       if (mem->flags & JAILHOUSE_MEM_WRITE)
                page_flags |= VTD_PAGE_WRITE;
 
        return page_map_create(cell->vtd.page_table, mem->phys_start,
@@ -316,7 +316,7 @@ void vtd_unmap_memory_region(struct cell *cell,
        if (dmar_units == 0)
                return;
 
-       if (mem->access_flags & JAILHOUSE_MEM_DMA)
+       if (mem->flags & JAILHOUSE_MEM_DMA)
                page_map_destroy(cell->vtd.page_table, mem->virt_start,
                                 mem->size, dmar_pt_levels, PAGE_MAP_COHERENT);
 }

diff --git a/hypervisor/control.c b/hypervisor/control.c
index 5542b3142a2232a1bc67c6992d605a044aee2210..efefacef45d3e86b47380caf20be575cb6543333 100644 (file)
--- a/hypervisor/control.c
+++ b/hypervisor/control.c
@@ -122,10 +122,10 @@ int check_mem_regions(const struct jailhouse_cell_desc *config)
                if (mem->phys_start & ~PAGE_MASK ||
                    mem->virt_start & ~PAGE_MASK ||
                    mem->size & ~PAGE_MASK ||
-                   mem->access_flags & ~JAILHOUSE_MEM_VALID_FLAGS) {
+                   mem->flags & ~JAILHOUSE_MEM_VALID_FLAGS) {
                        printk("FATAL: Invalid memory bar (%p, %p, %p, %x)\n",
                               mem->phys_start, mem->virt_start, mem->size,
-                              mem->access_flags);
+                              mem->flags);
                        return -EINVAL;
                }
        }
@@ -290,7 +290,7 @@ static void remap_to_linux(const struct jailhouse_memory *mem)
 
                overlap.virt_start = linux_mem->virt_start +
                        overlap.phys_start - linux_mem->phys_start;
-               overlap.access_flags = linux_mem->access_flags;
+               overlap.flags = linux_mem->flags;
 
                if (arch_map_memory_region(&linux_cell, &overlap) != 0)
                        printk("WARNING: Failed to re-assign memory region "

diff --git a/hypervisor/include/jailhouse/cell-config.h b/hypervisor/include/jailhouse/cell-config.h
index 9fa4a55ca549ec38669aeffddd3f615979aa4893..11931d20ea99fe84bf3e1cf9700b2e1fb89f82ba 100644 (file)
--- a/hypervisor/include/jailhouse/cell-config.h
+++ b/hypervisor/include/jailhouse/cell-config.h
@@ -22,7 +22,6 @@ struct jailhouse_cell_desc {
        __u32 num_memory_regions;
        __u32 num_irq_lines;
        __u32 pio_bitmap_size;
-
        __u32 num_pci_devices;
 
        __u32 padding[3];
@@ -42,7 +41,7 @@ struct jailhouse_memory {
        __u64 phys_start;
        __u64 virt_start;
        __u64 size;
-       __u64 access_flags;
+       __u64 flags;
 };
 
 struct jailhouse_irq_line {