From 55b40bc68a08ab582d01251398ee65f2e377fc76 Mon Sep 17 00:00:00 2001 From: Vladimir 'phcoder' Serbinenko Date: Mon, 11 Jan 2010 14:59:01 +0100 Subject: [PATCH] Ported linux to relocator framework --- include/grub/i386/relocator.h | 1 + lib/i386/relocator.c | 2 + lib/i386/relocator32.S | 7 ++ lib/relocator.c | 26 ++++--- loader/i386/linux.c | 125 +++++++++++++++------------------- 5 files changed, 83 insertions(+), 78 deletions(-) diff --git a/include/grub/i386/relocator.h b/include/grub/i386/relocator.h index 2027a275c..e4c9e7ca7 100644 --- a/include/grub/i386/relocator.h +++ b/include/grub/i386/relocator.h @@ -31,6 +31,7 @@ struct grub_relocator32_state grub_uint32_t ecx; grub_uint32_t edx; grub_uint32_t eip; + grub_uint32_t esi; }; grub_err_t grub_relocator32_boot (struct grub_relocator *rel, diff --git a/lib/i386/relocator.c b/lib/i386/relocator.c index 2396999bb..11e673cf7 100644 --- a/lib/i386/relocator.c +++ b/lib/i386/relocator.c @@ -47,6 +47,7 @@ extern grub_uint32_t grub_relocator32_ecx; extern grub_uint32_t grub_relocator32_edx; extern grub_uint32_t grub_relocator32_eip; extern grub_uint32_t grub_relocator32_esp; +extern grub_uint32_t grub_relocator32_esi; #define RELOCATOR_SIZEOF(x) (&grub_relocator##x##_end - &grub_relocator##x##_start) @@ -126,6 +127,7 @@ grub_relocator32_boot (struct grub_relocator *rel, grub_relocator32_edx = state.edx; grub_relocator32_eip = state.eip; grub_relocator32_esp = state.esp; + grub_relocator32_esi = state.esi; grub_memmove (src, &grub_relocator32_start, RELOCATOR_SIZEOF (32)); diff --git a/lib/i386/relocator32.S b/lib/i386/relocator32.S index f69e0bdc8..23bf65302 100644 --- a/lib/i386/relocator32.S +++ b/lib/i386/relocator32.S @@ -93,6 +93,13 @@ VARIABLE(grub_relocator32_esp) movl %eax, %esp + /* mov imm32, %eax */ + .byte 0xb8 +VARIABLE(grub_relocator32_esi) + .long 0 + + movl %eax, %esi + /* mov imm32, %eax */ .byte 0xb8 VARIABLE(grub_relocator32_eax) diff --git a/lib/relocator.c b/lib/relocator.c index 4b638cd66..71517d94b 100644 --- a/lib/relocator.c +++ b/lib/relocator.c @@ -99,6 +99,7 @@ get_best_header (struct grub_relocator *rel, hb = h; hbp = hp; *best_addr = addr; + grub_dprintf ("relocator", "picked %p/%x\n", hb, addr); } } else @@ -141,6 +142,7 @@ get_best_header (struct grub_relocator *rel, hb = h; hbp = hp; *best_addr = addr; + grub_dprintf ("relocator", "picked %p/%x\n", hb, addr); } } } @@ -188,8 +190,12 @@ malloc_in_range (struct grub_relocator *rel, grub_mm_region_t r, rp; for (rp = NULL, r = grub_mm_base; r; rp = r, r = r->next) { - if ((grub_addr_t) r + r->size + sizeof (*r) > start - && (grub_addr_t) r <= end && r->size + sizeof (*r) >= size + grub_dprintf ("relocator", "region %p. %d %d %d\n", r, + (grub_addr_t) r + r->size + sizeof (*r) >= start, + (grub_addr_t) r < end && r->size + sizeof (*r) >= size, + (rb == NULL || (from_low_priv ? rb > r : rb < r))); + if ((grub_addr_t) r + r->size + sizeof (*r) >= start + && (grub_addr_t) r < end && r->size + sizeof (*r) >= size && (rb == NULL || (from_low_priv ? rb > r : rb < r))) { rb = r; @@ -221,7 +227,7 @@ malloc_in_range (struct grub_relocator *rel, } /* Special case: relocating region start. */ - if (best_addr < (grub_addr_t) hbp) + if (best_addr < (grub_addr_t) hb) { grub_addr_t newreg_start, newreg_raw_start = best_addr + size; grub_addr_t newreg_size, newreg_presize; @@ -320,7 +326,8 @@ grub_relocator_alloc_chunk_addr (struct grub_relocator *rel, void **src, /* Keep chunks in memory in the same order as they'll be after relocation. */ for (chunk = rel->chunks; chunk; chunk = chunk->next) { - if (chunk->target > target && chunk->src > max_addr) + if (chunk->target > target && chunk->src < max_addr + && chunk->src < rel->postchunks) max_addr = chunk->src; if (chunk->target + chunk->size <= target && chunk->src + chunk->size > min_addr @@ -345,10 +352,10 @@ grub_relocator_alloc_chunk_addr (struct grub_relocator *rel, void **src, /* A trick to improve Linux allocation. */ #if defined (__i386__) || defined (__x86_64__) if (target < 0x100000) - if (malloc_in_range (rel, rel->highestnonpostaddr, ~(grub_addr_t)0, 0, - size, &start, 1, 0)) + if (malloc_in_range (rel, rel->highestnonpostaddr, ~(grub_addr_t)0, 1, + size, &start, 0, 1)) { - if (rel->postchunks < start) + if (rel->postchunks > start) rel->postchunks = start; break; } @@ -356,7 +363,7 @@ grub_relocator_alloc_chunk_addr (struct grub_relocator *rel, void **src, if (malloc_in_range (rel, target, max_addr, 1, size, &start, 1, 0)) break; - if (malloc_in_range (rel, min_addr, target, 0, size, &start, 1, 0)) + if (malloc_in_range (rel, min_addr, target, 1, size, &start, 0, 0)) break; grub_dprintf ("relocator", "not allocated\n"); @@ -436,7 +443,8 @@ grub_relocator_alloc_chunk_align (struct grub_relocator *rel, void **src, relocation. */ for (chunk = rel->chunks; chunk; chunk = chunk->next) { - if (chunk->target > max_addr && chunk->src > max_addr2) + if (chunk->target > max_addr && chunk->src > max_addr2 + && chunk->src < rel->postchunks) max_addr2 = chunk->src; if (chunk->target + chunk->size <= min_addr && chunk->src + chunk->size < min_addr2 diff --git a/loader/i386/linux.c b/loader/i386/linux.c index 43c455cd6..e8d06b0e7 100644 --- a/loader/i386/linux.c +++ b/loader/i386/linux.c @@ -34,6 +34,7 @@ #include #include #include +#include #include #define GRUB_LINUX_CL_OFFSET 0x1000 @@ -44,36 +45,18 @@ static grub_dl_t my_mod; static grub_size_t linux_mem_size; static int loaded; static void *real_mode_mem; +static grub_addr_t real_mode_target; static void *prot_mode_mem; +static grub_addr_t prot_mode_target; static void *initrd_mem; +static grub_addr_t initrd_mem_target; static grub_uint32_t real_mode_pages; static grub_uint32_t prot_mode_pages; static grub_uint32_t initrd_pages; +static struct grub_relocator *relocator = NULL; -static grub_uint8_t gdt[] __attribute__ ((aligned(16))) = - { - /* NULL. */ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - /* Reserved. */ - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - /* Code segment. */ - 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x9A, 0xCF, 0x00, - /* Data segment. */ - 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x92, 0xCF, 0x00 - }; - -struct gdt_descriptor -{ - grub_uint16_t limit; - void *base; -} __attribute__ ((packed)); - -static struct gdt_descriptor gdt_desc = - { - sizeof (gdt) - 1, - gdt - }; - +/* FIXME */ +#if 0 struct idt_descriptor { grub_uint16_t limit; @@ -85,6 +68,7 @@ static struct idt_descriptor idt_desc = 0, 0 }; +#endif #ifdef GRUB_MACHINE_PCBIOS struct linux_vesafb_res @@ -290,15 +274,19 @@ find_mmap_size (void) static void free_pages (void) { + grub_relocator_unload (relocator); + relocator = NULL; real_mode_mem = prot_mode_mem = initrd_mem = 0; + real_mode_target = prot_mode_target = initrd_mem_target = 0; } /* Allocate pages for the real mode code and the protected mode code for linux as well as a memory map buffer. */ -static int +static grub_err_t allocate_pages (grub_size_t prot_size) { grub_size_t real_size, mmap_size; + grub_err_t err; /* Make sure that each size is aligned to a page boundary. */ real_size = GRUB_LINUX_CL_END_OFFSET; @@ -316,6 +304,13 @@ allocate_pages (grub_size_t prot_size) /* Initialize the memory pointers with NULL for convenience. */ free_pages (); + relocator = grub_relocator_new (); + if (!relocator) + { + err = grub_errno; + goto fail; + } + /* FIXME: Should request low memory from the heap when this feature is implemented. */ @@ -339,32 +334,42 @@ allocate_pages (grub_size_t prot_size) if (real_size + mmap_size > size) return 0; - real_mode_mem = - (void *) (grub_size_t) ((addr + size) - (real_size + mmap_size)); + real_mode_target = ((addr + size) - (real_size + mmap_size)); return 1; } return 0; } grub_mmap_iterate (hook); - if (! real_mode_mem) + if (! real_mode_target) { - grub_error (GRUB_ERR_OUT_OF_MEMORY, "cannot allocate real mode pages"); + err = grub_error (GRUB_ERR_OUT_OF_MEMORY, "cannot allocate real mode pages"); goto fail; } - prot_mode_mem = (void *) 0x100000; + err = grub_relocator_alloc_chunk_addr (relocator, &real_mode_mem, + real_mode_target, + (real_size + mmap_size)); + if (err) + goto fail; + + prot_mode_target = 0x100000; + + err = grub_relocator_alloc_chunk_addr (relocator, &prot_mode_mem, + prot_mode_target, prot_size); + if (err) + goto fail; grub_dprintf ("linux", "real_mode_mem = %lx, real_mode_pages = %x, " "prot_mode_mem = %lx, prot_mode_pages = %x\n", (unsigned long) real_mode_mem, (unsigned) real_mode_pages, (unsigned long) prot_mode_mem, (unsigned) prot_mode_pages); - return 1; + return GRUB_ERR_NONE; fail: free_pages (); - return 0; + return err; } static void @@ -460,16 +465,12 @@ grub_linux_boot (void) int e820_num; grub_err_t err = 0; char *modevar, *tmp; + struct grub_relocator32_state state; params = real_mode_mem; - grub_dprintf ("linux", "code32_start = %x, idt_desc = %lx, gdt_desc = %lx\n", - (unsigned) params->code32_start, - (unsigned long) &(idt_desc.limit), - (unsigned long) &(gdt_desc.limit)); - grub_dprintf ("linux", "idt = %x:%lx, gdt = %x:%lx\n", - (unsigned) idt_desc.limit, (unsigned long) idt_desc.base, - (unsigned) gdt_desc.limit, (unsigned long) gdt_desc.base); + grub_dprintf ("linux", "code32_start = %x\n", + (unsigned) params->code32_start); auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t, grub_uint32_t); int NESTED_FUNC_ATTR hook (grub_uint64_t addr, grub_uint64_t size, grub_uint32_t type) @@ -568,31 +569,12 @@ grub_linux_boot (void) } } -#ifdef __x86_64__ - - grub_memcpy ((char *) prot_mode_mem + (prot_mode_pages << 12), - grub_linux_trampoline_start, - grub_linux_trampoline_end - grub_linux_trampoline_start); - - ((void (*) (unsigned long, void *)) ((char *) prot_mode_mem - + (prot_mode_pages << 12))) - (params->code32_start, real_mode_mem); -#else - - /* Hardware interrupts are not safe any longer. */ - asm volatile ("cli" : : ); - - /* Load the IDT and the GDT for the bootstrap. */ - asm volatile ("lidt %0" : : "m" (idt_desc)); - asm volatile ("lgdt %0" : : "m" (gdt_desc)); - - /* Enter Linux. */ - asm volatile ("jmp *%2" : : "b" (0), "S" (real_mode_mem), "g" (params->code32_start)); - -#endif - - /* Never reach here. */ - return GRUB_ERR_NONE; + /* FIXME. */ + /* asm volatile ("lidt %0" : : "m" (idt_desc)); */ + state.ebx = 0; + state.esi = real_mode_target; + state.eip = params->code32_start; + return grub_relocator32_boot (relocator, state); } static grub_err_t @@ -678,7 +660,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)), real_size = setup_sects << GRUB_DISK_SECTOR_BITS; prot_size = grub_file_size (file) - real_size - GRUB_DISK_SECTOR_SIZE; - if (! allocate_pages (prot_size)) + if (allocate_pages (prot_size)) goto fail; params = (struct linux_kernel_params *) real_mode_mem; @@ -701,7 +683,7 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)), params->cl_magic = GRUB_LINUX_CL_MAGIC; params->cl_offset = 0x1000; - params->cmd_line_ptr = (unsigned long) real_mode_mem + 0x1000; + params->cmd_line_ptr = real_mode_target + 0x1000; params->ramdisk_image = 0; params->ramdisk_size = 0; @@ -910,6 +892,7 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)), grub_ssize_t size; grub_addr_t addr_min, addr_max; grub_addr_t addr; + grub_err_t err; struct linux_kernel_header *lh; if (argc == 0) @@ -957,7 +940,7 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)), addr_max -= 0x10000; /* Usually, the compression ratio is about 50%. */ - addr_min = (grub_addr_t) prot_mode_mem + ((prot_mode_pages * 3) << 12) + addr_min = (grub_addr_t) prot_mode_target + ((prot_mode_pages * 3) << 12) + page_align (size); if (addr_max > grub_os_area_addr + grub_os_area_size) @@ -972,7 +955,11 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)), goto fail; } - initrd_mem = (void *) addr; + err = grub_relocator_alloc_chunk_align (relocator, &initrd_mem, + &initrd_mem_target, + addr_min, addr, size, 0x1000); + if (err) + return err; if (grub_file_read (file, initrd_mem, size) != size) { @@ -983,7 +970,7 @@ grub_cmd_initrd (grub_command_t cmd __attribute__ ((unused)), grub_dprintf ("linux", "Initrd, addr=0x%x, size=0x%x\n", (unsigned) addr, (unsigned) size); - lh->ramdisk_image = addr; + lh->ramdisk_image = initrd_mem_target; lh->ramdisk_size = size; lh->root_dev = 0x0100; /* XXX */