# HG changeset patch
# User awilliam@xxxxxxxxxxx
# Node ID 0a226de3fc37204cc75023f2bb31aa26831755a5
# Parent aa229873911204d675310d0dab06cd673eff7757
[IA64] Update efi.c and rework xenheap location
This is a port of a newer upsteam efi.c to xen/ia64. For the most
part, this patch is simply incorporating this upstream linux-ia64
patch into the tree:
http://www.kernel.org/hg/linux-2.6/?cs=fb781f6d3e81
To support this new code, xensetup needed to be modified to relocate
the dom0 kernel and initrd images without using efi_memmap_walk() as
this can no longer be called until after reserve_memory(). The dom0
kernel and initrd images are now only moved if necessary and the xen
MDT entry is expanded to cover the xenheap area and any relocated dom0
bits.
Signed-off-by: Alex Williamson <alex.williamson@xxxxxx>
---
xen/arch/ia64/linux-xen/efi.c | 472 ++++++++++++++-------------
xen/arch/ia64/linux-xen/setup.c | 3
xen/arch/ia64/xen/xensetup.c | 231 ++++++++-----
xen/include/asm-ia64/linux-xen/asm/meminit.h | 6
4 files changed, 416 insertions(+), 296 deletions(-)
diff -r aa2298739112 -r 0a226de3fc37 xen/arch/ia64/linux-xen/efi.c
--- a/xen/arch/ia64/linux-xen/efi.c Fri Jun 09 10:40:31 2006 -0600
+++ b/xen/arch/ia64/linux-xen/efi.c Tue Jun 13 08:45:22 2006 -0600
@@ -246,57 +246,30 @@ is_available_memory (efi_memory_desc_t *
return 0;
}
-/*
- * Trim descriptor MD so its starts at address START_ADDR. If the descriptor
covers
- * memory that is normally available to the kernel, issue a warning that some
memory
- * is being ignored.
- */
+typedef struct kern_memdesc {
+ u64 attribute;
+ u64 start;
+ u64 num_pages;
+} kern_memdesc_t;
+
+static kern_memdesc_t *kern_memmap;
+
static void
-trim_bottom (efi_memory_desc_t *md, u64 start_addr)
-{
- u64 num_skipped_pages;
-
- if (md->phys_addr >= start_addr || !md->num_pages)
- return;
-
- num_skipped_pages = (start_addr - md->phys_addr) >> EFI_PAGE_SHIFT;
- if (num_skipped_pages > md->num_pages)
- num_skipped_pages = md->num_pages;
-
- if (is_available_memory(md))
- printk(KERN_NOTICE "efi.%s: ignoring %luKB of memory at 0x%lx
due to granule hole "
- "at 0x%lx\n", __FUNCTION__,
- (num_skipped_pages << EFI_PAGE_SHIFT) >> 10,
- md->phys_addr, start_addr - IA64_GRANULE_SIZE);
- /*
- * NOTE: Don't set md->phys_addr to START_ADDR because that could cause
the memory
- * descriptor list to become unsorted. In such a case, md->num_pages
will be
- * zero, so the Right Thing will happen.
- */
- md->phys_addr += num_skipped_pages << EFI_PAGE_SHIFT;
- md->num_pages -= num_skipped_pages;
-}
-
-static void
-trim_top (efi_memory_desc_t *md, u64 end_addr)
-{
- u64 num_dropped_pages, md_end_addr;
-
- md_end_addr = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT);
-
- if (md_end_addr <= end_addr || !md->num_pages)
- return;
-
- num_dropped_pages = (md_end_addr - end_addr) >> EFI_PAGE_SHIFT;
- if (num_dropped_pages > md->num_pages)
- num_dropped_pages = md->num_pages;
-
- if (is_available_memory(md))
- printk(KERN_NOTICE "efi.%s: ignoring %luKB of memory at 0x%lx
due to granule hole "
- "at 0x%lx\n", __FUNCTION__,
- (num_dropped_pages << EFI_PAGE_SHIFT) >> 10,
- md->phys_addr, end_addr);
- md->num_pages -= num_dropped_pages;
+walk (efi_freemem_callback_t callback, void *arg, u64 attr)
+{
+ kern_memdesc_t *k;
+ u64 start, end, voff;
+
+ voff = (attr == EFI_MEMORY_WB) ? PAGE_OFFSET : __IA64_UNCACHED_OFFSET;
+ for (k = kern_memmap; k->start != ~0UL; k++) {
+ if (k->attribute != attr)
+ continue;
+ start = PAGE_ALIGN(k->start);
+ end = (k->start + (k->num_pages << EFI_PAGE_SHIFT)) & PAGE_MASK;
+ if (start < end)
+ if ((*callback)(start + voff, end + voff, arg) < 0)
+ return;
+ }
}
/*
@@ -306,153 +279,17 @@ void
void
efi_memmap_walk (efi_freemem_callback_t callback, void *arg)
{
- int prev_valid = 0;
- struct range {
- u64 start;
- u64 end;
- } prev, curr;
- void *efi_map_start, *efi_map_end, *p, *q;
- efi_memory_desc_t *md, *check_md;
- u64 efi_desc_size, start, end, granule_addr, last_granule_addr,
first_non_wb_addr = 0;
- unsigned long total_mem = 0;
-
- efi_map_start = __va(ia64_boot_param->efi_memmap);
- efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size;
- efi_desc_size = ia64_boot_param->efi_memdesc_size;
-
- for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
- md = p;
-
- /* skip over non-WB memory descriptors; that's all we're
interested in... */
- if (!(md->attribute & EFI_MEMORY_WB))
- continue;
-
-#ifdef XEN
-// this works around a problem in the ski bootloader
-{
- extern long running_on_sim;
- if (running_on_sim && md->type != EFI_CONVENTIONAL_MEMORY)
- continue;
-}
-#endif
- /*
- * granule_addr is the base of md's first granule.
- * [granule_addr - first_non_wb_addr) is guaranteed to
- * be contiguous WB memory.
- */
- granule_addr = GRANULEROUNDDOWN(md->phys_addr);
- first_non_wb_addr = max(first_non_wb_addr, granule_addr);
-
- if (first_non_wb_addr < md->phys_addr) {
- trim_bottom(md, granule_addr + IA64_GRANULE_SIZE);
- granule_addr = GRANULEROUNDDOWN(md->phys_addr);
- first_non_wb_addr = max(first_non_wb_addr,
granule_addr);
- }
-
- for (q = p; q < efi_map_end; q += efi_desc_size) {
- check_md = q;
-
- if ((check_md->attribute & EFI_MEMORY_WB) &&
- (check_md->phys_addr == first_non_wb_addr))
- first_non_wb_addr += check_md->num_pages <<
EFI_PAGE_SHIFT;
- else
- break; /* non-WB or hole */
- }
-
- last_granule_addr = GRANULEROUNDDOWN(first_non_wb_addr);
- if (last_granule_addr < md->phys_addr + (md->num_pages <<
EFI_PAGE_SHIFT))
- trim_top(md, last_granule_addr);
-
- if (is_available_memory(md)) {
- if (md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT)
>= max_addr) {
- if (md->phys_addr >= max_addr)
- continue;
- md->num_pages = (max_addr - md->phys_addr) >>
EFI_PAGE_SHIFT;
- first_non_wb_addr = max_addr;
- }
-
- if (total_mem >= mem_limit)
- continue;
-
- if (total_mem + (md->num_pages << EFI_PAGE_SHIFT) >
mem_limit) {
- unsigned long limit_addr = md->phys_addr;
-
- limit_addr += mem_limit - total_mem;
- limit_addr = GRANULEROUNDDOWN(limit_addr);
-
- if (md->phys_addr > limit_addr)
- continue;
-
- md->num_pages = (limit_addr - md->phys_addr) >>
- EFI_PAGE_SHIFT;
- first_non_wb_addr = max_addr = md->phys_addr +
- (md->num_pages << EFI_PAGE_SHIFT);
- }
- total_mem += (md->num_pages << EFI_PAGE_SHIFT);
-
- if (md->num_pages == 0)
- continue;
-
- curr.start = PAGE_OFFSET + md->phys_addr;
- curr.end = curr.start + (md->num_pages <<
EFI_PAGE_SHIFT);
-
- if (!prev_valid) {
- prev = curr;
- prev_valid = 1;
- } else {
- if (curr.start < prev.start)
- printk(KERN_ERR "Oops: EFI memory table
not ordered!\n");
-
- if (prev.end == curr.start) {
- /* merge two consecutive memory ranges
*/
- prev.end = curr.end;
- } else {
- start = PAGE_ALIGN(prev.start);
- end = prev.end & PAGE_MASK;
- if ((end > start) && (*callback)(start,
end, arg) < 0)
- return;
- prev = curr;
- }
- }
- }
- }
- if (prev_valid) {
- start = PAGE_ALIGN(prev.start);
- end = prev.end & PAGE_MASK;
- if (end > start)
- (*callback)(start, end, arg);
- }
+ walk(callback, arg, EFI_MEMORY_WB);
}
/*
- * Walk the EFI memory map to pull out leftover pages in the lower
- * memory regions which do not end up in the regular memory map and
- * stick them into the uncached allocator
- *
- * The regular walk function is significantly more complex than the
- * uncached walk which means it really doesn't make sense to try and
- * marge the two.
+ * Walks the EFI memory map and calls CALLBACK once for each EFI memory
descriptor that
+ * has memory that is available for uncached allocator.
*/
-void __init
-efi_memmap_walk_uc (efi_freemem_callback_t callback)
-{
- void *efi_map_start, *efi_map_end, *p;
- efi_memory_desc_t *md;
- u64 efi_desc_size, start, end;
-
- efi_map_start = __va(ia64_boot_param->efi_memmap);
- efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size;
- efi_desc_size = ia64_boot_param->efi_memdesc_size;
-
- for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
- md = p;
- if (md->attribute == EFI_MEMORY_UC) {
- start = PAGE_ALIGN(md->phys_addr);
- end = PAGE_ALIGN((md->phys_addr+(md->num_pages <<
EFI_PAGE_SHIFT)) & PAGE_MASK);
- if ((*callback)(start, end, NULL) < 0)
- return;
- }
- }
+void
+efi_memmap_walk_uc (efi_freemem_callback_t callback, void *arg)
+{
+ walk(callback, arg, EFI_MEMORY_UC);
}
#ifdef XEN
@@ -799,30 +636,6 @@ efi_get_iobase (void)
return 0;
}
-#ifdef XEN
-// variation of efi_get_iobase which returns entire memory descriptor
-efi_memory_desc_t *
-efi_get_io_md (void)
-{
- void *efi_map_start, *efi_map_end, *p;
- efi_memory_desc_t *md;
- u64 efi_desc_size;
-
- efi_map_start = __va(ia64_boot_param->efi_memmap);
- efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size;
- efi_desc_size = ia64_boot_param->efi_memdesc_size;
-
- for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
- md = p;
- if (md->type == EFI_MEMORY_MAPPED_IO_PORT_SPACE) {
- if (md->attribute & EFI_MEMORY_UC)
- return md;
- }
- }
- return 0;
-}
-#endif
-
u32
efi_mem_type (unsigned long phys_addr)
{
@@ -934,3 +747,228 @@ efi_uart_console_only(void)
printk(KERN_ERR "Malformed %s value\n", name);
return 0;
}
+
+#define efi_md_size(md) (md->num_pages << EFI_PAGE_SHIFT)
+
+static inline u64
+kmd_end(kern_memdesc_t *kmd)
+{
+ return (kmd->start + (kmd->num_pages << EFI_PAGE_SHIFT));
+}
+
+static inline u64
+efi_md_end(efi_memory_desc_t *md)
+{
+ return (md->phys_addr + efi_md_size(md));
+}
+
+static inline int
+efi_wb(efi_memory_desc_t *md)
+{
+ return (md->attribute & EFI_MEMORY_WB);
+}
+
+static inline int
+efi_uc(efi_memory_desc_t *md)
+{
+ return (md->attribute & EFI_MEMORY_UC);
+}
+
+/*
+ * Look for the first granule aligned memory descriptor memory
+ * that is big enough to hold EFI memory map. Make sure this
+ * descriptor is atleast granule sized so it does not get trimmed
+ */
+struct kern_memdesc *
+find_memmap_space (void)
+{
+ u64 contig_low=0, contig_high=0;
+ u64 as = 0, ae;
+ void *efi_map_start, *efi_map_end, *p, *q;
+ efi_memory_desc_t *md, *pmd = NULL, *check_md;
+ u64 space_needed, efi_desc_size;
+ unsigned long total_mem = 0;
+
+ efi_map_start = __va(ia64_boot_param->efi_memmap);
+ efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size;
+ efi_desc_size = ia64_boot_param->efi_memdesc_size;
+
+ /*
+ * Worst case: we need 3 kernel descriptors for each efi descriptor
+ * (if every entry has a WB part in the middle, and UC head and tail),
+ * plus one for the end marker.
+ */
+ space_needed = sizeof(kern_memdesc_t) *
+ (3 * (ia64_boot_param->efi_memmap_size/efi_desc_size) + 1);
+
+ for (p = efi_map_start; p < efi_map_end; pmd = md, p += efi_desc_size) {
+ md = p;
+ if (!efi_wb(md)) {
+ continue;
+ }
+ if (pmd == NULL || !efi_wb(pmd) || efi_md_end(pmd) !=
md->phys_addr) {
+ contig_low = GRANULEROUNDUP(md->phys_addr);
+ contig_high = efi_md_end(md);
+ for (q = p + efi_desc_size; q < efi_map_end; q +=
efi_desc_size) {
+ check_md = q;
+ if (!efi_wb(check_md))
+ break;
+ if (contig_high != check_md->phys_addr)
+ break;
+ contig_high = efi_md_end(check_md);
+ }
+ contig_high = GRANULEROUNDDOWN(contig_high);
+ }
+ if (!is_available_memory(md) || md->type == EFI_LOADER_DATA)
+ continue;
+
+ /* Round ends inward to granule boundaries */
+ as = max(contig_low, md->phys_addr);
+ ae = min(contig_high, efi_md_end(md));
+
+ /* keep within max_addr= command line arg */
+ ae = min(ae, max_addr);
+ if (ae <= as)
+ continue;
+
+ /* avoid going over mem= command line arg */
+ if (total_mem + (ae - as) > mem_limit)
+ ae -= total_mem + (ae - as) - mem_limit;
+
+ if (ae <= as)
+ continue;
+
+ if (ae - as > space_needed)
+ break;
+ }
+ if (p >= efi_map_end)
+ panic("Can't allocate space for kernel memory descriptors");
+
+ return __va(as);
+}
+
+/*
+ * Walk the EFI memory map and gather all memory available for kernel
+ * to use. We can allocate partial granules only if the unavailable
+ * parts exist, and are WB.
+ */
+void
+efi_memmap_init(unsigned long *s, unsigned long *e)
+{
+ struct kern_memdesc *k, *prev = 0;
+ u64 contig_low=0, contig_high=0;
+ u64 as, ae, lim;
+ void *efi_map_start, *efi_map_end, *p, *q;
+ efi_memory_desc_t *md, *pmd = NULL, *check_md;
+ u64 efi_desc_size;
+ unsigned long total_mem = 0;
+
+ k = kern_memmap = find_memmap_space();
+
+ efi_map_start = __va(ia64_boot_param->efi_memmap);
+ efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size;
+ efi_desc_size = ia64_boot_param->efi_memdesc_size;
+
+ for (p = efi_map_start; p < efi_map_end; pmd = md, p += efi_desc_size) {
+ md = p;
+ if (!efi_wb(md)) {
+ if (efi_uc(md) && (md->type == EFI_CONVENTIONAL_MEMORY
||
+ md->type == EFI_BOOT_SERVICES_DATA))
{
+ k->attribute = EFI_MEMORY_UC;
+ k->start = md->phys_addr;
+ k->num_pages = md->num_pages;
+ k++;
+ }
+ continue;
+ }
+#ifdef XEN
+// this works around a problem in the ski bootloader
+{
+ extern long running_on_sim;
+ if (running_on_sim && md->type != EFI_CONVENTIONAL_MEMORY)
+ continue;
+}
+#endif
+ if (pmd == NULL || !efi_wb(pmd) || efi_md_end(pmd) !=
md->phys_addr) {
+ contig_low = GRANULEROUNDUP(md->phys_addr);
+ contig_high = efi_md_end(md);
+ for (q = p + efi_desc_size; q < efi_map_end; q +=
efi_desc_size) {
+ check_md = q;
+ if (!efi_wb(check_md))
+ break;
+ if (contig_high != check_md->phys_addr)
+ break;
+ contig_high = efi_md_end(check_md);
+ }
+ contig_high = GRANULEROUNDDOWN(contig_high);
+ }
+ if (!is_available_memory(md))
+ continue;
+
+ /*
+ * Round ends inward to granule boundaries
+ * Give trimmings to uncached allocator
+ */
+ if (md->phys_addr < contig_low) {
+ lim = min(efi_md_end(md), contig_low);
+ if (efi_uc(md)) {
+ if (k > kern_memmap && (k-1)->attribute ==
EFI_MEMORY_UC &&
+ kmd_end(k-1) == md->phys_addr) {
+ (k-1)->num_pages += (lim -
md->phys_addr) >> EFI_PAGE_SHIFT;
+ } else {
+ k->attribute = EFI_MEMORY_UC;
+ k->start = md->phys_addr;
+ k->num_pages = (lim - md->phys_addr) >>
EFI_PAGE_SHIFT;
+ k++;
+ }
+ }
+ as = contig_low;
+ } else
+ as = md->phys_addr;
+
+ if (efi_md_end(md) > contig_high) {
+ lim = max(md->phys_addr, contig_high);
+ if (efi_uc(md)) {
+ if (lim == md->phys_addr && k > kern_memmap &&
+ (k-1)->attribute == EFI_MEMORY_UC &&
+ kmd_end(k-1) == md->phys_addr) {
+ (k-1)->num_pages += md->num_pages;
+ } else {
+ k->attribute = EFI_MEMORY_UC;
+ k->start = lim;
+ k->num_pages = (efi_md_end(md) - lim)
>> EFI_PAGE_SHIFT;
+ k++;
+ }
+ }
+ ae = contig_high;
+ } else
+ ae = efi_md_end(md);
+
+ /* keep within max_addr= command line arg */
+ ae = min(ae, max_addr);
+ if (ae <= as)
+ continue;
+
+ /* avoid going over mem= command line arg */
+ if (total_mem + (ae - as) > mem_limit)
+ ae -= total_mem + (ae - as) - mem_limit;
+
+ if (ae <= as)
+ continue;
+ if (prev && kmd_end(prev) == md->phys_addr) {
+ prev->num_pages += (ae - as) >> EFI_PAGE_SHIFT;
+ total_mem += ae - as;
+ continue;
+ }
+ k->attribute = EFI_MEMORY_WB;
+ k->start = as;
+ k->num_pages = (ae - as) >> EFI_PAGE_SHIFT;
+ total_mem += ae - as;
+ prev = k++;
+ }
+ k->start = ~0L; /* end-marker */
+
+ /* reserve the memory we are using for kern_memmap */
+ *s = (u64)kern_memmap;
+ *e = (u64)++k;
+}
diff -r aa2298739112 -r 0a226de3fc37 xen/arch/ia64/linux-xen/setup.c
--- a/xen/arch/ia64/linux-xen/setup.c Fri Jun 09 10:40:31 2006 -0600
+++ b/xen/arch/ia64/linux-xen/setup.c Tue Jun 13 08:45:22 2006 -0600
@@ -248,6 +248,9 @@ reserve_memory (void)
n++;
}
#endif
+
+ efi_memmap_init(&rsvd_region[n].start, &rsvd_region[n].end);
+ n++;
/* end of memory marker */
rsvd_region[n].start = ~0UL;
diff -r aa2298739112 -r 0a226de3fc37 xen/arch/ia64/xen/xensetup.c
--- a/xen/arch/ia64/xen/xensetup.c Fri Jun 09 10:40:31 2006 -0600
+++ b/xen/arch/ia64/xen/xensetup.c Tue Jun 13 08:45:22 2006 -0600
@@ -90,20 +90,6 @@ xen_count_pages(u64 start, u64 end, void
return 0;
}
-/* Find first hole after trunk for xen image */
-static int
-xen_find_first_hole(u64 start, u64 end, void *arg)
-{
- unsigned long *first_hole = arg;
-
- if ((*first_hole) == 0) {
- if ((start <= KERNEL_START) && (KERNEL_START < end))
- *first_hole = __pa(end);
- }
-
- return 0;
-}
-
static void __init do_initcalls(void)
{
initcall_t *call;
@@ -197,15 +183,64 @@ efi_print(void)
}
}
+/*
+ * These functions are utility functions for getting and
+ * testing memory descriptors for allocating the xenheap area.
+ */
+static efi_memory_desc_t *
+efi_get_md (unsigned long phys_addr)
+{
+ void *efi_map_start, *efi_map_end, *p;
+ efi_memory_desc_t *md;
+ u64 efi_desc_size;
+
+ efi_map_start = __va(ia64_boot_param->efi_memmap);
+ efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size;
+ efi_desc_size = ia64_boot_param->efi_memdesc_size;
+
+ for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
+ md = p;
+ if (phys_addr - md->phys_addr < (md->num_pages << EFI_PAGE_SHIFT))
+ return md;
+ }
+ return 0;
+}
+
+static int
+is_xenheap_usable_memory(efi_memory_desc_t *md)
+{
+ if (!(md->attribute & EFI_MEMORY_WB))
+ return 0;
+
+ switch (md->type) {
+ case EFI_LOADER_CODE:
+ case EFI_LOADER_DATA:
+ case EFI_BOOT_SERVICES_CODE:
+ case EFI_BOOT_SERVICES_DATA:
+ case EFI_CONVENTIONAL_MEMORY:
+ return 1;
+ }
+ return 0;
+}
+
+static inline int
+md_overlaps(efi_memory_desc_t *md, unsigned long phys_addr)
+{
+ return (phys_addr - md->phys_addr < (md->num_pages << EFI_PAGE_SHIFT));
+}
+
+#define MD_SIZE(md) (md->num_pages << EFI_PAGE_SHIFT)
+
void start_kernel(void)
{
unsigned char *cmdline;
void *heap_start;
- unsigned long nr_pages, firsthole_start;
+ unsigned long nr_pages;
unsigned long dom0_memory_start, dom0_memory_size;
unsigned long dom0_initrd_start, dom0_initrd_size;
- unsigned long initial_images_start, initial_images_end;
+ unsigned long md_end, relo_start, relo_end, relo_size = 0;
struct domain *idle_domain;
+ efi_memory_desc_t *kern_md, *last_md, *md;
#ifdef CONFIG_SMP
int i;
#endif
@@ -230,67 +265,111 @@ void start_kernel(void)
init_console();
set_printk_prefix("(XEN) ");
+ if (running_on_sim || ia64_boot_param->domain_start == 0 ||
+ ia64_boot_param->domain_size == 0) {
+ /* This is possible only with the old elilo, which does not support
+ a vmm. Fix now, and continue without initrd. */
+ printk ("Your elilo is not Xen-aware. Bootparams fixed\n");
+ ia64_boot_param->domain_start = ia64_boot_param->initrd_start;
+ ia64_boot_param->domain_size = ia64_boot_param->initrd_size;
+ ia64_boot_param->initrd_start = 0;
+ ia64_boot_param->initrd_size = 0;
+ }
+
/* xenheap should be in same TR-covered range with xen image */
xenheap_phys_end = xen_pstart + xenheap_size;
printk("xen image pstart: 0x%lx, xenheap pend: 0x%lx\n",
- xen_pstart, xenheap_phys_end);
-
- /* Find next hole */
- firsthole_start = 0;
- efi_memmap_walk(xen_find_first_hole, &firsthole_start);
-
- if (running_on_sim || ia64_boot_param->domain_start == 0
- || ia64_boot_param->domain_size == 0) {
- /* This is possible only with the old elilo, which does not support
- a vmm. Fix now, and continue without initrd. */
- printk ("Your elilo is not Xen-aware. Bootparams fixed\n");
- ia64_boot_param->domain_start = ia64_boot_param->initrd_start;
- ia64_boot_param->domain_size = ia64_boot_param->initrd_size;
- ia64_boot_param->initrd_start = 0;
- ia64_boot_param->initrd_size = 0;
- }
-
- initial_images_start = xenheap_phys_end;
- initial_images_end = initial_images_start +
- PAGE_ALIGN(ia64_boot_param->domain_size);
-
- /* also reserve space for initrd */
- if (ia64_boot_param->initrd_start && ia64_boot_param->initrd_size)
- initial_images_end += PAGE_ALIGN(ia64_boot_param->initrd_size);
- else {
- /* sanity cleanup */
- ia64_boot_param->initrd_size = 0;
- ia64_boot_param->initrd_start = 0;
- }
-
-
- /* Later may find another memory trunk, even away from xen image... */
- if (initial_images_end > firsthole_start) {
- printk("Not enough memory to stash the DOM0 kernel image.\n");
- printk("First hole:0x%lx, relocation end: 0x%lx\n",
- firsthole_start, initial_images_end);
- for ( ; ; );
- }
-
- /* This copy is time consuming, but elilo may load Dom0 image
- * within xenheap range */
- printk("ready to move Dom0 to 0x%lx with len %lx...", initial_images_start,
- ia64_boot_param->domain_size);
-
- memmove(__va(initial_images_start),
- __va(ia64_boot_param->domain_start),
- ia64_boot_param->domain_size);
- ia64_boot_param->domain_start = initial_images_start;
-
- printk("ready to move initrd to 0x%lx with len %lx...",
- initial_images_start+PAGE_ALIGN(ia64_boot_param->domain_size),
- ia64_boot_param->initrd_size);
-
memmove(__va(initial_images_start+PAGE_ALIGN(ia64_boot_param->domain_size)),
- __va(ia64_boot_param->initrd_start),
- ia64_boot_param->initrd_size);
- printk("Done\n");
- ia64_boot_param->initrd_start = initial_images_start +
- PAGE_ALIGN(ia64_boot_param->domain_size);
+ xen_pstart, xenheap_phys_end);
+
+ kern_md = md = efi_get_md(xen_pstart);
+ md_end = __pa(ia64_imva(&_end));
+ relo_start = xenheap_phys_end;
+
+ /*
+ * Scan through the memory descriptors after the kernel
+ * image to make sure we have enough room for the xenheap
+ * area, pushing out whatever may already be there.
+ */
+ while (relo_start + relo_size >= md_end) {
+ md = efi_get_md(md_end);
+
+ BUG_ON(!md);
+ BUG_ON(!is_xenheap_usable_memory(md));
+
+ md_end = md->phys_addr + MD_SIZE(md);
+ /*
+ * The dom0 kernel or initrd could overlap, reserve space
+ * at the end to relocate them later.
+ */
+ if (md->type == EFI_LOADER_DATA) {
+ /* Test for ranges we're not prepared to move */
+ BUG_ON(md_overlaps(md, __pa(ia64_boot_param)) ||
+ md_overlaps(md, ia64_boot_param->efi_memmap) ||
+ md_overlaps(md, ia64_boot_param->command_line));
+
+ relo_size += MD_SIZE(md);
+ /* If range overlaps the end, push out the relocation start */
+ if (md_end > relo_start)
+ relo_start = md_end;
+ }
+ }
+ last_md = md;
+ relo_end = relo_start + relo_size;
+
+ md_end = __pa(ia64_imva(&_end));
+
+ /*
+ * Move any relocated data out into the previously found relocation
+ * area. Any extra memory descriptrs are moved out to the end
+ * and set to zero pages.
+ */
+ for (md = efi_get_md(md_end) ;; md = efi_get_md(md_end)) {
+ md_end = md->phys_addr + MD_SIZE(md);
+
+ if (md->type == EFI_LOADER_DATA) {
+ unsigned long relo_offset;
+
+ if (md_overlaps(md, ia64_boot_param->domain_start)) {
+ relo_offset = ia64_boot_param->domain_start - md->phys_addr;
+ printk("Moving Dom0 kernel image: 0x%lx -> 0x%lx (%ld KiB)\n",
+ ia64_boot_param->domain_start, relo_start + relo_offset,
+ ia64_boot_param->domain_size >> 10);
+ ia64_boot_param->domain_start = relo_start + relo_offset;
+ }
+ if (ia64_boot_param->initrd_size &&
+ md_overlaps(md, ia64_boot_param->initrd_start)) {
+ relo_offset = ia64_boot_param->initrd_start - md->phys_addr;
+ printk("Moving Dom0 initrd image: 0x%lx -> 0x%lx (%ld KiB)\n",
+ ia64_boot_param->initrd_start, relo_start + relo_offset,
+ ia64_boot_param->initrd_size >> 10);
+ ia64_boot_param->initrd_start = relo_start + relo_offset;
+ }
+ memcpy(__va(relo_start), __va(md->phys_addr), MD_SIZE(md));
+ relo_start += MD_SIZE(md);
+ }
+
+ if (md == kern_md)
+ continue;
+ if (md == last_md)
+ break;
+
+ md->phys_addr = relo_end;
+ md->num_pages = 0;
+ }
+
+ /* Trim the last entry */
+ md->phys_addr = relo_end;
+ md->num_pages = (md_end - relo_end) >> EFI_PAGE_SHIFT;
+
+ /*
+ * Expand the new kernel/xenheap (and maybe dom0/initrd) out to
+ * the full size. This range will already be type EFI_LOADER_DATA,
+ * therefore the xenheap area is now protected being allocated for
+ * use by find_memmap_space() in efi.c
+ */
+ kern_md->num_pages = (relo_end - kern_md->phys_addr) >> EFI_PAGE_SHIFT;
+
+ reserve_memory();
/* first find highest page frame number */
max_page = 0;
@@ -310,8 +389,6 @@ void start_kernel(void)
heap_start = __va(init_boot_allocator(__pa(heap_start)));
printf("After heap_start: %p\n", heap_start);
- reserve_memory();
-
efi_memmap_walk(filter_rsvd_memory, init_boot_pages);
efi_memmap_walk(xen_count_pages, &nr_pages);
@@ -417,7 +494,7 @@ printk("About to call domain_create()\n"
* above our heap. The second module, if present, is an initrd ramdisk.
*/
printk("About to call construct_dom0()\n");
- dom0_memory_start = (unsigned long) __va(initial_images_start);
+ dom0_memory_start = (unsigned long) __va(ia64_boot_param->domain_start);
dom0_memory_size = ia64_boot_param->domain_size;
dom0_initrd_start = (unsigned long) __va(ia64_boot_param->initrd_start);
dom0_initrd_size = ia64_boot_param->initrd_size;
diff -r aa2298739112 -r 0a226de3fc37
xen/include/asm-ia64/linux-xen/asm/meminit.h
--- a/xen/include/asm-ia64/linux-xen/asm/meminit.h Fri Jun 09 10:40:31
2006 -0600
+++ b/xen/include/asm-ia64/linux-xen/asm/meminit.h Tue Jun 13 08:45:22
2006 -0600
@@ -22,13 +22,14 @@
* - dom0 code & data
* - initrd (optional)
#endif
+ * - Kernel memory map built from EFI memory map
*
* More could be added if necessary
*/
#ifndef XEN
-#define IA64_MAX_RSVD_REGIONS 5
+#define IA64_MAX_RSVD_REGIONS 6
#else
-#define IA64_MAX_RSVD_REGIONS 6
+#define IA64_MAX_RSVD_REGIONS 7
#endif
struct rsvd_region {
@@ -43,6 +44,7 @@ extern void reserve_memory (void);
extern void reserve_memory (void);
extern void find_initrd (void);
extern int filter_rsvd_memory (unsigned long start, unsigned long end, void
*arg);
+extern void efi_memmap_init(unsigned long *, unsigned long *);
/*
* For rounding an address to the next IA64_GRANULE_SIZE or order
_______________________________________________
Xen-changelog mailing list
Xen-changelog@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-changelog
|
Home