core: Keep a copy of configuration for cell lifetime

This will simplify the cell destruction where we have to assign the
memory regions and devices of the closing cell back to Linux.

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

diff --git a/hypervisor/arch/arm/include/asm/cell.h b/hypervisor/arch/arm/include/asm/cell.h
index 69d85f5a07d139d2196163190dd207f8b5dac800..2ea61b22460cae8f9007b33b841d7bd9fda3800c 100644 (file)
--- a/hypervisor/arch/arm/include/asm/cell.h
+++ b/hypervisor/arch/arm/include/asm/cell.h
@@ -19,8 +19,9 @@
 #include <jailhouse/cell-config.h>
 
 struct cell {
-       char name[JAILHOUSE_CELL_NAME_MAXLEN+1];
        unsigned int id;
+       unsigned int data_pages;
+       struct jailhouse_cell_desc *config;
 
        struct cpu_set *cpu_set;
        struct cpu_set small_cpu_set;

diff --git a/hypervisor/arch/arm/setup.c b/hypervisor/arch/arm/setup.c
index c3fcda02a6b8096a268c276aaf96ed3baeedcf3c..3c5cf369707471d73cedf5ec593c41d9062e30ff 100644 (file)
--- a/hypervisor/arch/arm/setup.c
+++ b/hypervisor/arch/arm/setup.c
@@ -12,8 +12,7 @@
 
 #include <jailhouse/entry.h>
 
-int arch_init_early(struct cell *linux_cell,
-                   struct jailhouse_cell_desc *config)
+int arch_init_early(struct cell *linux_cell)
 {
        return -ENOSYS;
 }
@@ -23,8 +22,7 @@ int arch_cpu_init(struct per_cpu *cpu_data)
        return -ENOSYS;
 }
 
-int arch_init_late(struct cell *linux_cell,
-                  struct jailhouse_cell_desc *config)
+int arch_init_late(struct cell *linux_cell)
 {
        return -ENOSYS;
 }
@@ -49,7 +47,7 @@ void arch_suspend_cpu(unsigned int cpu_id) {}
 void arch_resume_cpu(unsigned int cpu_id) {}
 void arch_reset_cpu(unsigned int cpu_id) {}
 void arch_shutdown_cpu(unsigned int cpu_id) {}
-int arch_cell_create(struct per_cpu *cpu_data, struct cell *new_cell,
-                    struct jailhouse_cell_desc *config) { return -ENOSYS; }
+int arch_cell_create(struct per_cpu *cpu_data, struct cell *new_cell)
+{ return -ENOSYS; }
 void *memcpy(void *dest, const void *src, unsigned long n) { return NULL; }
 void arch_dbg_write(const char *msg) {}

diff --git a/hypervisor/arch/x86/control.c b/hypervisor/arch/x86/control.c
index f8c1f53020fa09dd66877fb5c08b7c002b3e5954..7e374c7d5930862d324fbc23e77f685d34228974 100644 (file)
--- a/hypervisor/arch/x86/control.c
+++ b/hypervisor/arch/x86/control.c
@@ -13,15 +13,14 @@
 #include <jailhouse/control.h>
 #include <asm/vmx.h>
 
-int arch_cell_create(struct per_cpu *cpu_data, struct cell *new_cell,
-                    struct jailhouse_cell_desc *config)
+int arch_cell_create(struct per_cpu *cpu_data, struct cell *new_cell)
 {
        unsigned int cpu;
 
-       vmx_cell_shrink(cpu_data->cell, config);
+       vmx_cell_shrink(cpu_data->cell, new_cell->config);
 
        for_each_cpu_except(cpu, cpu_data->cell->cpu_set, cpu_data->cpu_id)
                per_cpu(cpu)->flush_caches = true;
 
-       return vmx_cell_init(new_cell, config);
+       return vmx_cell_init(new_cell);
 }

diff --git a/hypervisor/arch/x86/include/asm/cell.h b/hypervisor/arch/x86/include/asm/cell.h
index 87d83b06b2614232ce6cb559edb777f689c42a83..1aed04da8ff1447e39a691d2ca0c885bb96e18eb 100644 (file)
--- a/hypervisor/arch/x86/include/asm/cell.h
+++ b/hypervisor/arch/x86/include/asm/cell.h
@@ -29,8 +29,9 @@ struct cell {
                pgd_t *page_table;
        } vtd;
 
-       char name[JAILHOUSE_CELL_NAME_MAXLEN+1];
        unsigned int id;
+       unsigned int data_pages;
+       struct jailhouse_cell_desc *config;
 
        struct cpu_set *cpu_set;
        struct cpu_set small_cpu_set;

diff --git a/hypervisor/arch/x86/include/asm/vmx.h b/hypervisor/arch/x86/include/asm/vmx.h
index 4b9607140e5970f2dd98672a8d198bd5421659e0..7e46b90bfcd502fe1ce9229f77f57f64dbf89598 100644 (file)
--- a/hypervisor/arch/x86/include/asm/vmx.h
+++ b/hypervisor/arch/x86/include/asm/vmx.h
@@ -282,7 +282,7 @@ enum vmcs_field {
 
 void vmx_init(void);
 
-int vmx_cell_init(struct cell *cell, struct jailhouse_cell_desc *config);
+int vmx_cell_init(struct cell *cell);
 void vmx_cell_shrink(struct cell *cell, struct jailhouse_cell_desc *config);
 
 int vmx_cpu_init(struct per_cpu *cpu_data);

diff --git a/hypervisor/arch/x86/include/asm/vtd.h b/hypervisor/arch/x86/include/asm/vtd.h
index adcc233498f7c07f2c51d06ca445c43a97cd2239..22ac0a0a85b52d2cdd60d78b6e3b65391a390970 100644 (file)
--- a/hypervisor/arch/x86/include/asm/vtd.h
+++ b/hypervisor/arch/x86/include/asm/vtd.h
@@ -86,5 +86,5 @@ struct vtd_entry {
 #define VTD_PHMLIMIT_REG               0x78
 
 int vtd_init(void);
-int vtd_cell_init(struct cell *cell, struct jailhouse_cell_desc *config);
+int vtd_cell_init(struct cell *cell);
 void vtd_shutdown(void);

diff --git a/hypervisor/arch/x86/setup.c b/hypervisor/arch/x86/setup.c
index fc180a238c83520b19a00244de4c4006093f9cb7..2f2eb3bf4044542b68b12300a6fe86147552cc4e 100644 (file)
--- a/hypervisor/arch/x86/setup.c
+++ b/hypervisor/arch/x86/setup.c
@@ -41,8 +41,7 @@ extern u8 nmi_entry[];
 
 static u32 idt[NUM_IDT_DESC * 4];
 
-int arch_init_early(struct cell *linux_cell,
-                   struct jailhouse_cell_desc *config)
+int arch_init_early(struct cell *linux_cell)
 {
        unsigned long entry;
        unsigned int vector;
@@ -70,7 +69,7 @@ int arch_init_early(struct cell *linux_cell,
 
        vmx_init();
 
-       err = vmx_cell_init(linux_cell, config);
+       err = vmx_cell_init(linux_cell);
        if (err)
                return err;
 
@@ -202,8 +201,7 @@ error_out:
        return err;
 }
 
-int arch_init_late(struct cell *linux_cell,
-                  struct jailhouse_cell_desc *config)
+int arch_init_late(struct cell *linux_cell)
 {
        int err;
 
@@ -211,7 +209,7 @@ int arch_init_late(struct cell *linux_cell,
        if (err)
                return err;
 
-       err = vtd_cell_init(linux_cell, config);
+       err = vtd_cell_init(linux_cell);
        if (err)
                return err;
 

diff --git a/hypervisor/arch/x86/vmx.c b/hypervisor/arch/x86/vmx.c
index aa2622d3925ae4602c8d29b62d6c5402db53f2ec..b1dff430c22cfb40b5fa1ad6aec76a0a36a9bda6 100644 (file)
--- a/hypervisor/arch/x86/vmx.c
+++ b/hypervisor/arch/x86/vmx.c
@@ -160,8 +160,9 @@ void vmx_init(void)
        msr_bitmap[VMX_MSR_BITMAP_0000_WRITE][MSR_X2APIC_ICR/8] = 0x01;
 }
 
-int vmx_cell_init(struct cell *cell, struct jailhouse_cell_desc *config)
+int vmx_cell_init(struct cell *cell)
 {
+       struct jailhouse_cell_desc *config = cell->config;
        struct jailhouse_memory *mem;
        u32 page_flags, table_flags;
        u32 pio_bitmap_size, size;

diff --git a/hypervisor/arch/x86/vtd.c b/hypervisor/arch/x86/vtd.c
index 11473e9c3f532d3c5e6bbcba2f60ca3e588ccb04..c49094084f00d169d1c3f2124abc0425595deb38 100644 (file)
--- a/hypervisor/arch/x86/vtd.c
+++ b/hypervisor/arch/x86/vtd.c
@@ -127,8 +127,9 @@ static bool vtd_add_device_to_cell(struct cell *cell,
        return true;
 }
 
-int vtd_cell_init(struct cell *cell, struct jailhouse_cell_desc *config)
+int vtd_cell_init(struct cell *cell)
 {
+       struct jailhouse_cell_desc *config = cell->config;
        struct jailhouse_pci_device *dev;
        void *reg_base = dmar_reg_base;
        struct jailhouse_memory *mem;

diff --git a/hypervisor/control.c b/hypervisor/control.c
index cbd6a3f0cdb215abd632f0c18edb9ed24a10458c..25c5934485ba577d6b1c25d67095761377797b31 100644 (file)
--- a/hypervisor/control.c
+++ b/hypervisor/control.c
@@ -38,7 +38,7 @@ static void cell_suspend(struct per_cpu *cpu_data)
 
        for_each_cpu_except(cpu, cell->cpu_set, cpu_data->cpu_id)
                arch_suspend_cpu(cpu);
-       printk("Suspended cell \"%s\"\n", cell->name);
+       printk("Suspended cell \"%s\"\n", cell->config->name);
 }
 
 static void cell_resume(struct per_cpu *cpu_data)
@@ -64,19 +64,17 @@ retry:
        return id;
 }
 
-int cell_init(struct cell *cell, struct jailhouse_cell_desc *config,
-             bool copy_cpu_set)
+int cell_init(struct cell *cell, bool copy_cpu_set)
 {
        unsigned long *config_cpu_set =
-               (unsigned long *)(((void *)config) +
+               (unsigned long *)(((void *)cell->config) +
                                  sizeof(struct jailhouse_cell_desc));
-       unsigned long cpu_set_size = config->cpu_set_size;
+       unsigned long cpu_set_size = cell->config->cpu_set_size;
        struct jailhouse_memory *config_ram =
                (struct jailhouse_memory *)(((void *)config_cpu_set) +
                                            cpu_set_size);
        struct cpu_set *cpu_set;
 
-       memcpy(cell->name, config->name, sizeof(cell->name));
        cell->id = get_free_cell_id();
 
        if (cpu_set_size > PAGE_SIZE)
@@ -112,7 +110,7 @@ static struct cell *cell_find(const char *name)
        struct cell *cell;
 
        for (cell = &linux_cell; cell; cell = cell->next)
-               if (strcmp(cell->name, name) == 0)
+               if (strcmp(cell->config->name, name) == 0)
                        break;
        return cell;
 }
@@ -143,7 +141,7 @@ int cell_create(struct per_cpu *cpu_data, unsigned long config_address)
 {
        unsigned long mapping_addr = FOREIGN_MAPPING_BASE +
                cpu_data->cpu_id * PAGE_SIZE * NUM_FOREIGN_PAGES;
-       unsigned long header_size, total_size;
+       unsigned long cfg_header_size, cfg_total_size;
        struct jailhouse_cell_desc *cfg;
        struct cpu_set *shrinking_set;
        unsigned int cell_pages, cpu;
@@ -152,19 +150,20 @@ int cell_create(struct per_cpu *cpu_data, unsigned long config_address)
 
        cell_suspend(cpu_data);
 
-       header_size = (config_address & ~PAGE_MASK) +
+       cfg_header_size = (config_address & ~PAGE_MASK) +
                sizeof(struct jailhouse_cell_desc);
 
        err = page_map_create(hv_page_table, config_address & PAGE_MASK,
-                             header_size, mapping_addr, PAGE_READONLY_FLAGS,
-                             PAGE_DEFAULT_FLAGS, PAGE_DIR_LEVELS);
+                             cfg_header_size, mapping_addr,
+                             PAGE_READONLY_FLAGS, PAGE_DEFAULT_FLAGS,
+                             PAGE_DIR_LEVELS);
        if (err)
                goto resume_out;
 
        cfg = (struct jailhouse_cell_desc *)(mapping_addr +
                                             (config_address & ~PAGE_MASK));
-       total_size = jailhouse_cell_config_size(cfg);
-       if (total_size > NUM_FOREIGN_PAGES * PAGE_SIZE) {
+       cfg_total_size = jailhouse_cell_config_size(cfg);
+       if (cfg_total_size > NUM_FOREIGN_PAGES * PAGE_SIZE) {
                err = -E2BIG;
                goto resume_out;
        }
@@ -175,8 +174,9 @@ int cell_create(struct per_cpu *cpu_data, unsigned long config_address)
        }
 
        err = page_map_create(hv_page_table, config_address & PAGE_MASK,
-                             total_size, mapping_addr, PAGE_READONLY_FLAGS,
-                             PAGE_DEFAULT_FLAGS, PAGE_DIR_LEVELS);
+                             cfg_total_size, mapping_addr,
+                             PAGE_READONLY_FLAGS, PAGE_DEFAULT_FLAGS,
+                             PAGE_DIR_LEVELS);
        if (err)
                goto resume_out;
 
@@ -184,14 +184,18 @@ int cell_create(struct per_cpu *cpu_data, unsigned long config_address)
        if (err)
                goto resume_out;
 
-       cell_pages = PAGE_ALIGN(sizeof(*cell)) / PAGE_SIZE;
+       cell_pages = PAGE_ALIGN(sizeof(*cell) + cfg_total_size) / PAGE_SIZE;
        cell = page_alloc(&mem_pool, cell_pages);
        if (!cell) {
                err = -ENOMEM;
                goto resume_out;
        }
 
-       err = cell_init(cell, cfg, true);
+       cell->data_pages = cell_pages;
+       cell->config = ((void *)cell) + sizeof(*cell);
+       memcpy(cell->config, cfg, cfg_total_size);
+
+       err = cell_init(cell, true);
        if (err)
                goto err_free_cell;
 
@@ -218,7 +222,7 @@ int cell_create(struct per_cpu *cpu_data, unsigned long config_address)
        for_each_cpu(cpu, cell->cpu_set)
                clear_bit(cpu, shrinking_set->bitmap);
 
-       err = arch_cell_create(cpu_data, cell, cfg);
+       err = arch_cell_create(cpu_data, cell);
        if (err)
                goto err_restore_cpu_set;
 
@@ -232,7 +236,7 @@ int cell_create(struct per_cpu *cpu_data, unsigned long config_address)
        for_each_cpu(cpu, cell->cpu_set)
                per_cpu(cpu)->cell = cell;
 
-       printk("Created cell \"%s\"\n", cell->name);
+       printk("Created cell \"%s\"\n", cell->config->name);
 
        page_map_dump_stats("after cell creation");
 
@@ -276,7 +280,7 @@ int shutdown(struct per_cpu *cpu_data)
                printk("Shutting down hypervisor\n");
 
                while (cell) {
-                       printk(" Closing cell \"%s\"\n", cell->name);
+                       printk(" Closing cell \"%s\"\n", cell->config->name);
 
                        for_each_cpu(cpu, cell->cpu_set) {
                                printk("  Releasing CPU %d\n", cpu);
@@ -285,7 +289,8 @@ int shutdown(struct per_cpu *cpu_data)
                        cell = cell->next;
                }
 
-               printk(" Closing Linux cell \"%s\"\n", linux_cell.name);
+               printk(" Closing Linux cell \"%s\"\n",
+                      linux_cell.config->name);
        }
        printk("  Releasing CPU %d\n", this_cpu);
 

diff --git a/hypervisor/include/jailhouse/control.h b/hypervisor/include/jailhouse/control.h
index 6467b4aff8eecb6b1cd146accfbb7e706e53dd5d..5677c296a05e3ecf03f0b0fcaba25d121cf12616 100644 (file)
--- a/hypervisor/include/jailhouse/control.h
+++ b/hypervisor/include/jailhouse/control.h
@@ -32,8 +32,7 @@ unsigned int next_cpu(unsigned int cpu, struct cpu_set *cpu_set,
            )
 
 int check_mem_regions(struct jailhouse_cell_desc *config);
-int cell_init(struct cell *cell, struct jailhouse_cell_desc *config,
-             bool copy_cpu_set);
+int cell_init(struct cell *cell, bool copy_cpu_set);
 
 int cell_create(struct per_cpu *cpu_data, unsigned long config_address);
 int cell_destroy(struct per_cpu *cpu_data, unsigned long name_address);
@@ -45,5 +44,4 @@ void arch_resume_cpu(unsigned int cpu_id);
 void arch_reset_cpu(unsigned int cpu_id);
 void arch_shutdown_cpu(unsigned int cpu_id);
 
-int arch_cell_create(struct per_cpu *cpu_data, struct cell *new_cell,
-                    struct jailhouse_cell_desc *config);
+int arch_cell_create(struct per_cpu *cpu_data, struct cell *new_cell);

diff --git a/hypervisor/include/jailhouse/entry.h b/hypervisor/include/jailhouse/entry.h
index 0a836b2cd86eb7b9f2f4eea9c9c79114fdb8d037..d1d49c53338aa71d13053973541e32cf6034bf0b 100644 (file)
--- a/hypervisor/include/jailhouse/entry.h
+++ b/hypervisor/include/jailhouse/entry.h
@@ -37,11 +37,9 @@ void vm_exit(void);
 
 int entry(struct per_cpu *cpu_data);
 
-int arch_init_early(struct cell *linux_cell,
-                   struct jailhouse_cell_desc *config);
+int arch_init_early(struct cell *linux_cell);
 int arch_cpu_init(struct per_cpu *cpu_data);
-int arch_init_late(struct cell *linux_cell,
-                  struct jailhouse_cell_desc *config);
+int arch_init_late(struct cell *linux_cell);
 void __attribute__((noreturn)) arch_cpu_activate_vmm(struct per_cpu *cpu_data);
 void arch_cpu_restore(struct per_cpu *cpu_data);
 

diff --git a/hypervisor/setup.c b/hypervisor/setup.c
index 3a2fd787fdaca32c35e04caba885eba3fc60ef05..519ef264b28c384fe0bf91ce23c2abf7a40339a0 100644 (file)
--- a/hypervisor/setup.c
+++ b/hypervisor/setup.c
@@ -63,6 +63,8 @@ static void init_early(unsigned int cpu_id)
        if (error)
                return;
 
+       linux_cell.config = &system_config->system;
+
        if (system_config->config_memory.size > 0) {
                size = PAGE_ALIGN(system_config->config_memory.size);
 
@@ -85,11 +87,11 @@ static void init_early(unsigned int cpu_id)
        if (error)
                return;
 
-       error = arch_init_early(&linux_cell, &system_config->system);
+       error = arch_init_early(&linux_cell);
        if (error)
                return;
 
-       error = cell_init(&linux_cell, &system_config->system, false);
+       error = cell_init(&linux_cell, false);
        if (error)
                return;
 
@@ -128,7 +130,7 @@ failed:
 
 static void init_late(void)
 {
-       error = arch_init_late(&linux_cell, &system_config->system);
+       error = arch_init_late(&linux_cell);
        if (error)
                return;