|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [Xen-devel] [PATCH 03/14] xen: arm: allocate dom0 memory separately from preparing the dtb
Mixing these two together is a pain, it forces us to prepare the dtb before
processing the kernel which means we don't know whether the guest is 32- or
64-bit while we construct its DTB.
Instead split out the memory allocation (including 1:1 workaround handling)
and p2m setup into a separate phase and then create a memory node in the DTB
based on the result.
This allows us to move kernel parsing before DTB setup.
Signed-off-by: Ian Campbell <ian.campbell@xxxxxxxxxx>
---
v2: Fixed typo in the commit log
Handle multiple memory nodes as well as individual nodes with several
entries in them.
Strip the original memory node and recreate rather than trying to modify.
---
xen/arch/arm/domain_build.c | 158 +++++++++++++++++++++++++++-----------------
1 file changed, 98 insertions(+), 60 deletions(-)
diff --git a/xen/arch/arm/domain_build.c b/xen/arch/arm/domain_build.c
index c644be2..6e482a9 100644
--- a/xen/arch/arm/domain_build.c
+++ b/xen/arch/arm/domain_build.c
@@ -63,11 +63,8 @@ struct vcpu *__init alloc_dom0_vcpu0(void)
return alloc_vcpu(dom0, 0, 0);
}
-static int set_memory_reg_11(struct domain *d, struct kernel_info *kinfo,
- const struct dt_property *pp,
- const struct dt_device_node *np, __be32 *new_cell)
+static void allocate_memory_11(struct domain *d, struct kernel_info *kinfo)
{
- int reg_size = dt_cells_to_size(dt_n_addr_cells(np) + dt_n_size_cells(np));
paddr_t start;
paddr_t size;
struct page_info *pg = NULL;
@@ -98,53 +95,61 @@ static int set_memory_reg_11(struct domain *d, struct
kernel_info *kinfo,
if ( res )
panic("Unable to add pages in DOM0: %d\n", res);
- dt_set_range(&new_cell, np, start, size);
-
kinfo->mem.bank[0].start = start;
kinfo->mem.bank[0].size = size;
kinfo->mem.nr_banks = 1;
- return reg_size;
+ kinfo->unassigned_mem -= size;
}
-static int set_memory_reg(struct domain *d, struct kernel_info *kinfo,
- const struct dt_property *pp,
- const struct dt_device_node *np, __be32 *new_cell)
+static void allocate_memory(struct domain *d, struct kernel_info *kinfo)
{
- int reg_size = dt_cells_to_size(dt_n_addr_cells(np) + dt_n_size_cells(np));
- int l = 0;
+
+ struct dt_device_node *memory = NULL;
+ const void *reg;
+ u32 reg_len, reg_size;
unsigned int bank = 0;
- u64 start;
- u64 size;
- int ret;
if ( platform_has_quirk(PLATFORM_QUIRK_DOM0_MAPPING_11) )
- return set_memory_reg_11(d, kinfo, pp, np, new_cell);
+ return allocate_memory_11(d, kinfo);
- while ( kinfo->unassigned_mem > 0 && l + reg_size <= pp->length
- && kinfo->mem.nr_banks < NR_MEM_BANKS )
+ while ( (memory = dt_find_node_by_type(memory, "memory")) )
{
- ret = dt_device_get_address(np, bank, &start, &size);
- if ( ret )
- panic("Unable to retrieve the bank %u for %s\n",
- bank, dt_node_full_name(np));
-
- if ( size > kinfo->unassigned_mem )
- size = kinfo->unassigned_mem;
- dt_set_range(&new_cell, np, start, size);
-
- printk("Populate P2M %#"PRIx64"->%#"PRIx64"\n", start, start + size);
- if ( p2m_populate_ram(d, start, start + size) < 0 )
- panic("Failed to populate P2M\n");
- kinfo->mem.bank[kinfo->mem.nr_banks].start = start;
- kinfo->mem.bank[kinfo->mem.nr_banks].size = size;
- kinfo->mem.nr_banks++;
- kinfo->unassigned_mem -= size;
-
- l += reg_size;
- }
+ int l;
+
+ DPRINT("memory node\n");
+
+ reg_size = dt_cells_to_size(dt_n_addr_cells(memory) +
dt_n_size_cells(memory));
- return l;
+ reg = dt_get_property(memory, "reg", ®_len);
+ if ( reg == NULL )
+ panic("Memory node has no reg property!\n");
+
+ for ( l = 0;
+ kinfo->unassigned_mem > 0 && l + reg_size <= reg_len
+ && kinfo->mem.nr_banks < NR_MEM_BANKS;
+ l += reg_size )
+ {
+ paddr_t start, size;
+
+ if ( dt_device_get_address(memory, bank, &start, &size) )
+ panic("Unable to retrieve the bank %u for %s\n",
+ bank, dt_node_full_name(memory));
+
+ if ( size > kinfo->unassigned_mem )
+ size = kinfo->unassigned_mem;
+
+ printk("Populate P2M %#"PRIx64"->%#"PRIx64"\n",
+ start, start + size);
+ if ( p2m_populate_ram(d, start, start + size) < 0 )
+ panic("Failed to populate P2M\n");
+ kinfo->mem.bank[kinfo->mem.nr_banks].start = start;
+ kinfo->mem.bank[kinfo->mem.nr_banks].size = size;
+ kinfo->mem.nr_banks++;
+
+ kinfo->unassigned_mem -= size;
+ }
+ }
}
static int write_properties(struct domain *d, struct kernel_info *kinfo,
@@ -193,23 +198,6 @@ static int write_properties(struct domain *d, struct
kernel_info *kinfo,
continue;
}
}
- /*
- * In a memory node: adjust reg property.
- * TODO: handle properly memory node (ie: device_type = "memory")
- */
- else if ( dt_node_name_is_equal(np, "memory") )
- {
- if ( dt_property_name_is_equal(pp, "reg") )
- {
- new_data = xzalloc_bytes(pp->length);
- if ( new_data == NULL )
- return -FDT_ERR_XEN(ENOMEM);
-
- prop_len = set_memory_reg(d, kinfo, pp, np,
- (__be32 *)new_data);
- prop_data = new_data;
- }
- }
res = fdt_property(kinfo->fdt, pp->name, prop_data, prop_len);
@@ -286,6 +274,46 @@ static int fdt_property_interrupts(void *fdt,
gic_interrupt_t *intr,
return res;
}
+static int make_memory_node(struct domain *d,
+ void *fdt, const struct dt_device_node *np,
+ const struct kernel_info *kinfo)
+{
+ int res, i;
+ int reg_size = dt_cells_to_size(dt_n_addr_cells(np) + dt_n_size_cells(np));
+ __be32 reg[reg_size*kinfo->mem.nr_banks];
+ __be32 *cells;
+
+ DPRINT("Create memory node\n");
+
+ /* ePAPR 3.4 */
+ res = fdt_begin_node(fdt, "memory");
+ if ( res )
+ return res;
+
+ res = fdt_property_string(fdt, "device_type", "memory");
+ if ( res )
+ return res;
+
+ cells = ®[0];
+ for ( i = 0 ; i < kinfo->mem.nr_banks; i++ )
+ {
+ u64 start = kinfo->mem.bank[i].start;
+ u64 size = kinfo->mem.bank[i].size;
+
+ DPRINT(" Bank %d: %#"PRIx64"->%#"PRIx64"\n",
+ i, start, start + size);
+
+ dt_set_range(&cells, np, start, size);
+ }
+
+ res = fdt_property(fdt, "reg", reg, reg_size*kinfo->mem.nr_banks);
+ if ( res )
+ return res;
+
+ res = fdt_end_node(fdt);
+
+ return res;
+}
static int make_hypervisor_node(void *fdt, const struct dt_device_node *parent)
{
@@ -690,6 +718,7 @@ static int handle_node(struct domain *d, struct kernel_info
*kinfo,
DT_MATCH_COMPATIBLE("xen,multiboot-module"),
DT_MATCH_COMPATIBLE("arm,psci"),
DT_MATCH_PATH("/cpus"),
+ DT_MATCH_TYPE("memory"),
DT_MATCH_GIC,
DT_MATCH_TIMER,
{ /* sentinel */ },
@@ -754,6 +783,10 @@ static int handle_node(struct domain *d, struct
kernel_info *kinfo,
if ( np == dt_host )
{
+ res = make_memory_node(d, kinfo->fdt, np, kinfo);
+ if ( res )
+ return res;
+
res = make_hypervisor_node(kinfo->fdt, np);
if ( res )
return res;
@@ -791,8 +824,6 @@ static int prepare_dtb(struct domain *d, struct kernel_info
*kinfo)
ASSERT(dt_host && (dt_host->sibling == NULL));
- kinfo->unassigned_mem = dom0_mem;
-
fdt = device_tree_flattened;
new_size = fdt_totalsize(fdt) + DOM0_FDT_EXTRA_SIZE;
@@ -938,11 +969,19 @@ int construct_dom0(struct domain *d)
d->max_pages = ~0U;
- rc = prepare_dtb(d, &kinfo);
+ kinfo.unassigned_mem = dom0_mem;
+
+ allocate_memory(d, &kinfo);
+
+ rc = kernel_prepare(&kinfo);
if ( rc < 0 )
return rc;
- rc = kernel_prepare(&kinfo);
+#ifdef CONFIG_ARM_64
+ d->arch.type = kinfo.type;
+#endif
+
+ rc = prepare_dtb(d, &kinfo);
if ( rc < 0 )
return rc;
@@ -977,7 +1016,6 @@ int construct_dom0(struct domain *d)
regs->pc = (register_t)kinfo.entry;
-
if ( is_pv32_domain(d) )
{
regs->cpsr = PSR_GUEST32_INIT;
--
1.8.4.rc3
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxx
http://lists.xen.org/xen-devel
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |