diff options
Diffstat (limited to 'hw/pc.c')
| -rw-r--r-- | hw/pc.c | 246 |
1 files changed, 238 insertions, 8 deletions
@@ -40,6 +40,9 @@ /* output Bochs bios info messages */ //#define DEBUG_BIOS +/* Show multiboot debug output */ +//#define DEBUG_MULTIBOOT + #define BIOS_FILENAME "bios.bin" #define VGABIOS_FILENAME "vgabios.bin" #define VGABIOS_CIRRUS_FILENAME "vgabios-cirrus.bin" @@ -596,7 +599,218 @@ static long get_file_size(FILE *f) return size; } -static void load_linux(target_phys_addr_t option_rom, +#define MULTIBOOT_STRUCT_ADDR 0x9000 + +#if MULTIBOOT_STRUCT_ADDR > 0xf0000 +#error multiboot struct needs to fit in 16 bit real mode +#endif + +static int load_multiboot(void *fw_cfg, + FILE *f, + const char *kernel_filename, + const char *initrd_filename, + const char *kernel_cmdline, + uint8_t *header) +{ + int i, t, is_multiboot = 0; + uint32_t flags = 0; + uint32_t mh_entry_addr; + uint32_t mh_load_addr; + uint32_t mb_kernel_size; + uint32_t mmap_addr = MULTIBOOT_STRUCT_ADDR; + uint32_t mb_bootinfo = MULTIBOOT_STRUCT_ADDR + 0x500; + uint32_t mb_cmdline = mb_bootinfo + 0x200; + uint32_t mb_mod_end; + + /* Ok, let's see if it is a multiboot image. + The header is 12x32bit long, so the latest entry may be 8192 - 48. */ + for (i = 0; i < (8192 - 48); i += 4) { + if (ldl_p(header+i) == 0x1BADB002) { + uint32_t checksum = ldl_p(header+i+8); + flags = ldl_p(header+i+4); + checksum += flags; + checksum += (uint32_t)0x1BADB002; + if (!checksum) { + is_multiboot = 1; + break; + } + } + } + + if (!is_multiboot) + return 0; /* no multiboot */ + +#ifdef DEBUG_MULTIBOOT + fprintf(stderr, "qemu: I believe we found a multiboot image!\n"); +#endif + + if (flags & 0x00000004) { /* MULTIBOOT_HEADER_HAS_VBE */ + fprintf(stderr, "qemu: multiboot knows VBE. we don't.\n"); + } + if (!(flags & 0x00010000)) { /* MULTIBOOT_HEADER_HAS_ADDR */ + uint64_t elf_entry; + int kernel_size; + fclose(f); + kernel_size = load_elf(kernel_filename, 0, &elf_entry, NULL, NULL); + if (kernel_size < 0) { + fprintf(stderr, "Error while loading elf kernel\n"); + exit(1); + } + mh_load_addr = mh_entry_addr = elf_entry; + mb_kernel_size = kernel_size; + +#ifdef DEBUG_MULTIBOOT + fprintf(stderr, "qemu: loading multiboot-elf kernel (%#x bytes) with entry %#zx\n", + mb_kernel_size, (size_t)mh_entry_addr); +#endif + } else { + /* Valid if mh_flags sets MULTIBOOT_HEADER_HAS_ADDR. */ + uint32_t mh_header_addr = ldl_p(header+i+12); + mh_load_addr = ldl_p(header+i+16); +#ifdef DEBUG_MULTIBOOT + uint32_t mh_load_end_addr = ldl_p(header+i+20); + uint32_t mh_bss_end_addr = ldl_p(header+i+24); +#endif + uint32_t mb_kernel_text_offset = i - (mh_header_addr - mh_load_addr); + + mh_entry_addr = ldl_p(header+i+28); + mb_kernel_size = get_file_size(f) - mb_kernel_text_offset; + + /* Valid if mh_flags sets MULTIBOOT_HEADER_HAS_VBE. + uint32_t mh_mode_type = ldl_p(header+i+32); + uint32_t mh_width = ldl_p(header+i+36); + uint32_t mh_height = ldl_p(header+i+40); + uint32_t mh_depth = ldl_p(header+i+44); */ + +#ifdef DEBUG_MULTIBOOT + fprintf(stderr, "multiboot: mh_header_addr = %#x\n", mh_header_addr); + fprintf(stderr, "multiboot: mh_load_addr = %#x\n", mh_load_addr); + fprintf(stderr, "multiboot: mh_load_end_addr = %#x\n", mh_load_end_addr); + fprintf(stderr, "multiboot: mh_bss_end_addr = %#x\n", mh_bss_end_addr); +#endif + + fseek(f, mb_kernel_text_offset, SEEK_SET); + +#ifdef DEBUG_MULTIBOOT + fprintf(stderr, "qemu: loading multiboot kernel (%#x bytes) at %#x\n", + mb_kernel_size, mh_load_addr); +#endif + + if (!fread_targphys_ok(mh_load_addr, mb_kernel_size, f)) { + fprintf(stderr, "qemu: read error on multiboot kernel '%s' (%#x)\n", + kernel_filename, mb_kernel_size); + exit(1); + } + fclose(f); + } + + /* blob size is only the kernel for now */ + mb_mod_end = mh_load_addr + mb_kernel_size; + + /* load modules */ + stl_phys(mb_bootinfo + 20, 0x0); /* mods_count */ + if (initrd_filename) { + uint32_t mb_mod_info = mb_bootinfo + 0x100; + uint32_t mb_mod_cmdline = mb_bootinfo + 0x300; + uint32_t mb_mod_start = mh_load_addr; + uint32_t mb_mod_length = mb_kernel_size; + char *next_initrd; + char *next_space; + int mb_mod_count = 0; + + do { + next_initrd = strchr(initrd_filename, ','); + if (next_initrd) + *next_initrd = '\0'; + /* if a space comes after the module filename, treat everything + after that as parameters */ + cpu_physical_memory_write(mb_mod_cmdline, (uint8_t*)initrd_filename, + strlen(initrd_filename) + 1); + stl_phys(mb_mod_info + 8, mb_mod_cmdline); /* string */ + mb_mod_cmdline += strlen(initrd_filename) + 1; + if ((next_space = strchr(initrd_filename, ' '))) + *next_space = '\0'; +#ifdef DEBUG_MULTIBOOT + printf("multiboot loading module: %s\n", initrd_filename); +#endif + f = fopen(initrd_filename, "rb"); + if (f) { + mb_mod_start = (mb_mod_start + mb_mod_length + (TARGET_PAGE_SIZE - 1)) + & (TARGET_PAGE_MASK); + mb_mod_length = get_file_size(f); + mb_mod_end = mb_mod_start + mb_mod_length; + + if (!fread_targphys_ok(mb_mod_start, mb_mod_length, f)) { + fprintf(stderr, "qemu: read error on multiboot module '%s' (%#x)\n", + initrd_filename, mb_mod_length); + exit(1); + } + + mb_mod_count++; + stl_phys(mb_mod_info + 0, mb_mod_start); + stl_phys(mb_mod_info + 4, mb_mod_start + mb_mod_length); +#ifdef DEBUG_MULTIBOOT + printf("mod_start: %#x\nmod_end: %#x\n", mb_mod_start, + mb_mod_start + mb_mod_length); +#endif + stl_phys(mb_mod_info + 12, 0x0); /* reserved */ + } + initrd_filename = next_initrd+1; + mb_mod_info += 16; + } while (next_initrd); + stl_phys(mb_bootinfo + 20, mb_mod_count); /* mods_count */ + stl_phys(mb_bootinfo + 24, mb_bootinfo + 0x100); /* mods_addr */ + } + + /* Make sure we're getting kernel + modules back after reset */ + option_rom_setup_reset(mh_load_addr, mb_mod_end - mh_load_addr); + + /* Commandline support */ + stl_phys(mb_bootinfo + 16, mb_cmdline); + t = strlen(kernel_filename); + cpu_physical_memory_write(mb_cmdline, (uint8_t*)kernel_filename, t); + mb_cmdline += t; + stb_phys(mb_cmdline++, ' '); + t = strlen(kernel_cmdline) + 1; + cpu_physical_memory_write(mb_cmdline, (uint8_t*)kernel_cmdline, t); + + /* the kernel is where we want it to be now */ + +#define MULTIBOOT_FLAGS_MEMORY (1 << 0) +#define MULTIBOOT_FLAGS_BOOT_DEVICE (1 << 1) +#define MULTIBOOT_FLAGS_CMDLINE (1 << 2) +#define MULTIBOOT_FLAGS_MODULES (1 << 3) +#define MULTIBOOT_FLAGS_MMAP (1 << 6) + stl_phys(mb_bootinfo, MULTIBOOT_FLAGS_MEMORY + | MULTIBOOT_FLAGS_BOOT_DEVICE + | MULTIBOOT_FLAGS_CMDLINE + | MULTIBOOT_FLAGS_MODULES + | MULTIBOOT_FLAGS_MMAP); + stl_phys(mb_bootinfo + 4, 640); /* mem_lower */ + stl_phys(mb_bootinfo + 8, ram_size / 1024); /* mem_upper */ + stl_phys(mb_bootinfo + 12, 0x8001ffff); /* XXX: use the -boot switch? */ + stl_phys(mb_bootinfo + 48, mmap_addr); /* mmap_addr */ + +#ifdef DEBUG_MULTIBOOT + fprintf(stderr, "multiboot: mh_entry_addr = %#x\n", mh_entry_addr); +#endif + + /* Pass variables to option rom */ + fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, mh_entry_addr); + fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, mb_bootinfo); + fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, mmap_addr); + + /* Make sure we're getting the config space back after reset */ + option_rom_setup_reset(mb_bootinfo, 0x500); + + option_rom[nb_option_roms] = "multiboot.bin"; + nb_option_roms++; + + return 1; /* yes, we are multiboot */ +} + +static void load_linux(void *fw_cfg, + target_phys_addr_t option_rom, const char *kernel_filename, const char *initrd_filename, const char *kernel_cmdline, @@ -608,7 +822,7 @@ static void load_linux(target_phys_addr_t option_rom, uint16_t real_seg; int setup_size, kernel_size, initrd_size = 0, cmdline_size; uint32_t initrd_max; - uint8_t header[1024]; + uint8_t header[8192]; target_phys_addr_t real_addr, prot_addr, cmdline_addr, initrd_addr = 0; FILE *f, *fi; @@ -618,7 +832,8 @@ static void load_linux(target_phys_addr_t option_rom, /* load the kernel header */ f = fopen(kernel_filename, "rb"); if (!f || !(kernel_size = get_file_size(f)) || - fread(header, 1, 1024, f) != 1024) { + fread(header, 1, MIN(ARRAY_SIZE(header), kernel_size), f) != + MIN(ARRAY_SIZE(header), kernel_size)) { fprintf(stderr, "qemu: could not load kernel '%s'\n", kernel_filename); exit(1); @@ -630,8 +845,14 @@ static void load_linux(target_phys_addr_t option_rom, #endif if (ldl_p(header+0x202) == 0x53726448) protocol = lduw_p(header+0x206); - else + else { + /* This looks like a multiboot kernel. If it is, let's stop + treating it like a Linux kernel. */ + if (load_multiboot(fw_cfg, f, kernel_filename, + initrd_filename, kernel_cmdline, header)) + return; protocol = 0; + } if (protocol < 0x200 || !(header[0x211] & 0x01)) { /* Low kernel */ @@ -721,16 +942,25 @@ static void load_linux(target_phys_addr_t option_rom, } /* store the finalized header and load the rest of the kernel */ - cpu_physical_memory_write(real_addr, header, 1024); + cpu_physical_memory_write(real_addr, header, ARRAY_SIZE(header)); setup_size = header[0x1f1]; if (setup_size == 0) setup_size = 4; setup_size = (setup_size+1)*512; - kernel_size -= setup_size; /* Size of protected-mode code */ + /* Size of protected-mode code */ + kernel_size -= (setup_size > ARRAY_SIZE(header)) ? setup_size : ARRAY_SIZE(header); + + /* In case we have read too much already, copy that over */ + if (setup_size < ARRAY_SIZE(header)) { + cpu_physical_memory_write(prot_addr, header + setup_size, ARRAY_SIZE(header) - setup_size); + prot_addr += (ARRAY_SIZE(header) - setup_size); + setup_size = ARRAY_SIZE(header); + } - if (!fread_targphys_ok(real_addr+1024, setup_size-1024, f) || + if (!fread_targphys_ok(real_addr + ARRAY_SIZE(header), + setup_size - ARRAY_SIZE(header), f) || !fread_targphys_ok(prot_addr, kernel_size, f)) { fprintf(stderr, "qemu: read error on kernel '%s'\n", kernel_filename); @@ -978,7 +1208,7 @@ static void pc_init1(ram_addr_t ram_size, fw_cfg = bochs_bios_init(); if (linux_boot) { - load_linux(0xc0000 + oprom_area_size, + load_linux(fw_cfg, 0xc0000 + oprom_area_size, kernel_filename, initrd_filename, kernel_cmdline, below_4g_mem_size); oprom_area_size += 2048; } |