Skip to contentSkip to conversation

Add multiboot support (x86)

PATCH In review Alexander Graf 6 participants 13 messages Jun 17, 2009 – Jun 18, 2009

lore
Share & tools
lore
#0 lore raw

cover Add multiboot support (x86)

This patch implements support for Multiboot on x86 for -kernel. Multiboot is a "new" approach to get rid of different bootloaders, providing a unified interface for the kernel. It supports command line options and kernel modules.

The two probably best known projects using multiboot are Xen and GNU Hurd.

This implementation should be mostly feature-complete. It is missing VBE extensions, but as no system uses them currently it does not really hurt.

To use multiboot, specify the kernel as -kernel option. Modules should be given as -initrd options, seperated by a comma (,). -append also works.

Please bear in mind that grub also does gzip decompression, which qemu does not do yet. To run existing images, please ungzip them first.

The guest multiboot loader code is implemented as option rom using int 19. Parts of the work are based on efforts by Rene Rebe, who originally ported my code to int 19.

Also, Kevin Wolf helped a lot whenever I had a new version of this patch around.

Alexander Graf (4):
Change bochs bios init order
Expose fw_cfg
Multiboot support
Multiboot build system

 hw/pc.c                       |  241 ++++++++++++++++++++++++++++++++++++++---
 pc-bios/multiboot/Makefile    |   41 +++++++
 pc-bios/multiboot/multiboot.S |  229 +++++++++++++++++++++++++++++++++++++++
 pc-bios/multiboot/signrom.c   |   79 ++++++++++++++
 target-i386/cpu.h             |    3 +
 5 files changed, 577 insertions(+), 16 deletions(-)
 create mode 100644 pc-bios/multiboot/Makefile
 create mode 100644 pc-bios/multiboot/multiboot.S
 create mode 100644 pc-bios/multiboot/signrom.c
#1 lore raw

PATCH 1/4 Change bochs bios init order

For multiboot support, we need bochs_bios_init to happen before load_linux, so we get the fw_cfg device.

---
 hw/pc.c |   12 ++++++------
 1 files changed, 6 insertions(+), 6 deletions(-)
hw/pc.c +6 -6
index 143b697..f0df669 100644
@@ -970,6 +970,12 @@ static void pc_init1(ram_addr_t ram_size,
     if (oprom_area_size < 0x8000)
         oprom_area_size = 0x8000;
 
+    /* map all the bios at the top of memory */
+    cpu_register_physical_memory((uint32_t)(-bios_size),
+                                 bios_size, bios_offset | IO_MEM_ROM);
+
+    bochs_bios_init();
+
     if (linux_boot) {
         load_linux(0xc0000 + oprom_area_size,
                    kernel_filename, initrd_filename, kernel_cmdline, below_4g_mem_size);
@@ -981,12 +987,6 @@ static void pc_init1(ram_addr_t ram_size,
                                            0xc0000 + oprom_area_size, 0xe0000);
     }
 
-    /* map all the bios at the top of memory */
-    cpu_register_physical_memory((uint32_t)(-bios_size),
-                                 bios_size, bios_offset | IO_MEM_ROM);
-
-    bochs_bios_init();
-
     cpu_irq = qemu_allocate_irqs(pic_irq_request, NULL, 1);
     i8259 = i8259_init(cpu_irq[0]);
     ferr_irq = i8259[13];
Signature · 1 line
1.6.0.2
#2 lore raw

PATCH 2/4 Expose fw_cfg

Multiboot passes options to the option rom using the fw_cfg device. Right now, that device is local to the bochs_bios_init function.

Let's change that and expose it to env, so everyone may put data in there.

---
 hw/pc.c           |    8 +++++---
 target-i386/cpu.h |    3 +++
 2 files changed, 8 insertions(+), 3 deletions(-)
hw/pc.c +5 -3
index f0df669..171447e 100644
@@ -448,7 +448,7 @@ static void bochs_bios_write(void *opaque, uint32_t addr, uint32_t val)
 
 extern uint64_t node_cpumask[MAX_NODES];
 
-static void bochs_bios_init(void)
+static void bochs_bios_init(CPUState *env)
 {
     void *fw_cfg;
     uint8_t *smbios_table;
@@ -468,6 +468,8 @@ static void bochs_bios_init(void)
     register_ioport_write(0x503, 1, 1, bochs_bios_write, NULL);
 
     fw_cfg = fw_cfg_init(BIOS_CFG_IOPORT, BIOS_CFG_IOPORT + 1, 0, 0);
+    env->fw_cfg = fw_cfg;
+
     fw_cfg_add_i32(fw_cfg, FW_CFG_ID, 1);
     fw_cfg_add_i64(fw_cfg, FW_CFG_RAM_SIZE, (uint64_t)ram_size);
     fw_cfg_add_bytes(fw_cfg, FW_CFG_ACPI_TABLES, (uint8_t *)acpi_tables,
@@ -849,7 +851,7 @@ static void pc_init1(ram_addr_t ram_size,
     int bios_size, isa_bios_size, oprom_area_size;
     PCIBus *pci_bus;
     int piix3_devfn = -1;
-    CPUState *env;
+    CPUState *env = NULL;
     qemu_irq *cpu_irq;
     qemu_irq *i8259;
     int index;
@@ -974,7 +976,7 @@ static void pc_init1(ram_addr_t ram_size,
     cpu_register_physical_memory((uint32_t)(-bios_size),
                                  bios_size, bios_offset | IO_MEM_ROM);
 
-    bochs_bios_init();
+    bochs_bios_init(env);
 
     if (linux_boot) {
         load_linux(0xc0000 + oprom_area_size,
target-i386/cpu.h +3 -0
index d7b32d4..9fef0f7 100644
@@ -676,6 +676,9 @@ typedef struct CPUX86State {
     /* in order to simplify APIC support, we leave this pointer to the
        user */
     struct APICState *apic_state;
+
+    /* Firmware configuration device */
+    void *fw_cfg;
 } CPUX86State;
 
 CPUX86State *cpu_x86_init(const char *cpu_model);
Signature · 1 line
1.6.0.2
#3 lore raw

PATCH 3/4 Multiboot support

This patch implements support for Multiboot on x86 for -kernel. Multiboot is a "new" approach to get rid of different bootloaders, providing a unified interface for the kernel. It supports command line options and kernel modules.

The two probably best known projects using multiboot are Xen and GNU Hurd.

This implementation should be mostly feature-complete. It is missing VBE extensions, but as no system uses them currently it does not really hurt.

To use multiboot, specify the kernel as -kernel option. Modules should be given as -initrd options, seperated by a comma (,). -append also works.

Please bear in mind that grub also does gzip decompression, which qemu does not do yet. To run existing images, please ungzip them first.

The guest multiboot loader code is implemented as option rom using int 19. Parts of the work are based on efforts by Rene Rebe, who originally ported my code to int 19.

---
 hw/pc.c                       |  223 ++++++++++++++++++++++++++++++++++++++--
 pc-bios/multiboot/multiboot.S |  229 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 444 insertions(+), 8 deletions(-)
 create mode 100644 pc-bios/multiboot/multiboot.S
hw/pc.c +217 -8
index 171447e..608c433 100644
@@ -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"
@@ -595,7 +598,197 @@ static long get_file_size(FILE *f)
     return size;
 }
 
-static void load_linux(target_phys_addr_t option_rom,
+static int load_multiboot(CPUState *env,
+                          FILE *f,
+                          const char *kernel_filename,
+                          const char *initrd_filename,
+                          const char *kernel_cmdline,
+                          uint8_t *header)
+{
+    int i, is_multiboot = 0;
+    uint32_t flags = 0;
+    uint32_t mh_entry_addr;
+    uint32_t mh_load_addr;
+    uint32_t mb_kernel_size;
+    uint32_t mb_bootinfo = 0x90500;
+    uint32_t mmap_addr = 0x90000;
+
+    /* 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);
+    }
+
+
+    /* 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);
+
+                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 */
+    }
+
+    /* Commandline support */
+    stl_phys(mb_bootinfo + 16, mb_bootinfo + 0x200);
+    cpu_physical_memory_write(mb_bootinfo + 0x200, (uint8_t*)kernel_cmdline,
+                              strlen(kernel_cmdline) + 1);
+
+    /* 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(env->fw_cfg, FW_CFG_KERNEL_ADDR, mh_entry_addr);
+    fw_cfg_add_i32(env->fw_cfg, FW_CFG_INITRD_ADDR, mb_bootinfo);
+    fw_cfg_add_i32(env->fw_cfg, FW_CFG_INITRD_SIZE, mmap_addr);
+
+    option_rom[nb_option_roms] = "multiboot.bin";
+    nb_option_roms++;
+
+    return 1; /* yes, we are multiboot */
+}
+
+static void load_linux(CPUState *env,
+                       target_phys_addr_t option_rom,
                        const char *kernel_filename,
 		       const char *initrd_filename,
 		       const char *kernel_cmdline,
@@ -607,7 +798,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;
 
@@ -617,7 +808,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);
@@ -629,8 +821,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(env, f, kernel_filename,
+                           initrd_filename, kernel_cmdline, header))
+	   return;
 	protocol = 0;
+    }
 
     if (protocol < 0x200 || !(header[0x211] & 0x01)) {
 	/* Low kernel */
@@ -720,16 +918,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);
@@ -979,7 +1186,7 @@ static void pc_init1(ram_addr_t ram_size,
     bochs_bios_init(env);
 
     if (linux_boot) {
-        load_linux(0xc0000 + oprom_area_size,
+        load_linux(env, 0xc0000 + oprom_area_size,
                    kernel_filename, initrd_filename, kernel_cmdline, below_4g_mem_size);
         oprom_area_size += 2048;
     }
pc-bios/multiboot/multiboot.S new file +229 -0

229 lines not on this page · raw message

Signature · 1 line
1.6.0.2
#4 lore raw

PATCH 4/4 Multiboot build system

In order to build the multiboot option rom, we need a Makefile and a tool to sign the rom with.

Both are provided by this patch and mostly taken from the extboot source, written by Anthony Liguori.

Once built, please copy the multiboot.bin file to your pc-bios directory to actually be able to use the option rom.

---
 pc-bios/multiboot/Makefile  |   41 ++++++++++++++++++++++
 pc-bios/multiboot/signrom.c |   79 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 120 insertions(+), 0 deletions(-)
 create mode 100644 pc-bios/multiboot/Makefile
 create mode 100644 pc-bios/multiboot/signrom.c
pc-bios/multiboot/Makefile new file +41 -0
new file mode 100644
index 0000000..0e7a764
@@ -0,0 +1,41 @@
+OBJCOPY=objcopy
+
+# from kernel sources - scripts/Kbuild.include
+# try-run
+# Usage: option = $(call try-run, $(CC)...-o "$$TMP",option-ok,otherwise)
+# Exit code chooses option. "$$TMP" is can be used as temporary file and
+# is automatically cleaned up.
+try-run = $(shell set -e;		\
+	TMP="$(TMPOUT).$$$$.tmp";	\
+	if ($(1)) >/dev/null 2>&1;	\
+	then echo "$(2)";		\
+	else echo "$(3)";		\
+	fi;				\
+	rm -f "$$TMP")
+
+# cc-option-yn
+# Usage: flag := $(call cc-option-yn,-march=winchip-c6)
+cc-option-yn = $(call try-run,\
+	$(CC) $(KBUILD_CFLAGS) $(1) -S -xc /dev/null -o "$$TMP",y,n)
+
+CFLAGS = -Wall -Wstrict-prototypes -Werror -fomit-frame-pointer -fno-builtin
+ifeq ($(call cc-option-yn,-fno-stack-protector),y)
+CFLAGS += -fno-stack-protector
+endif
+
+all: multiboot.bin
+
+%.o: %.S
+	$(CC) $(CFLAGS) -o $@ -c $<
+
+multiboot.img: multiboot.o
+	$(LD) --oformat binary -Ttext 0 -o $@ $<
+
+multiboot.bin: multiboot.img signrom
+	./signrom multiboot.img multiboot.bin
+
+signrom: signrom.c
+	$(CC) -o $@ -g -Wall $^
+
+clean:
+	$(RM) *.o *.img *.bin signrom *~
pc-bios/multiboot/signrom.c new file +79 -0

79 lines not on this page · raw message

Signature · 1 line
1.6.0.2
#5 lore raw

Re: [Qemu-devel] [PATCH 4/4] Multiboot build system

Quoted 2 lines · Alexander Graf

In order to build the multiboot option rom, we need a Makefile and a tool to sign the rom with.

This appears to assume $(CC) is a useful i386 compiler (or assembler), and that your object file contains no relocations. The former is not all that likely, and the latter is very fragile.

Paul

#6 lore raw

Re: [Qemu-devel] [PATCH 4/4] Multiboot build system

Quoted 7 lines · Paul Brook
Quoted 2 lines · Alexander Graf

In order to build the multiboot option rom, we need a Makefile and a tool to sign the rom with.

This appears to assume $(CC) is a useful i386 compiler (or assembler), and that your object file contains no relocations. The former is not all that likely, and the latter is very fragile.

Yes, which is why you're only supposed to compile this on an i386 machine and the resulting binary should be pushed to pc-bios by whoever commits this.

Isn't that the same as all the rest in pc-bios? Well - with the exception that this time we have the source and not only some patches ;-).

The relocations are always an issue. If you know about a magic compiler option that tells the compiler "scream of you find relocations", please tell me.

Alex

#7 lore raw

[Qemu-devel] Re: [PATCH 4/4] Multiboot build system

Quoted 2 lines

The relocations are always an issue. If you know about a magic compiler option that tells the compiler "scream of you find relocations", please tell me.

You can do a normal ELF link and use readelf on the output.

Paolo

#8 lore raw

[Qemu-devel] Re: [PATCH 4/4] Multiboot build system

Quoted 4 lines · Paolo Bonzini
Quoted 2 lines

The relocations are always an issue. If you know about a magic compiler option that tells the compiler "scream of you find relocations", please tell me.

You can do a normal ELF link and use readelf on the output.

Hm I just tried to put in an external relocation (mov %eax, FOO) and ld already complained about it. What issue exactly were you talking about Paul?

Alex

#9 lore raw

Re: [Qemu-devel] Re: [PATCH 4/4] Multiboot build system

Quoted 6 lines
Quoted 3 lines
Quoted 1 line

The relocations are always an issue. If you know about a magic compiler option that tells the compiler "scream of you find relocations", please tell me.

You can do a normal ELF link and use readelf on the output.

Hm I just tried to put in an external relocation (mov %eax, FOO) and ld already complained about it. What issue exactly were you talking about Paul?

Just in case you were confusing Paolo B. (me) with Paul B., my suggestion was just a way to find relocations assuming ld would not complain. Possibly Paul's (his) observation does not apply to binary output.

Paolo

#10 lore raw

Re: [Qemu-devel] [PATCH 2/4] Expose fw_cfg

In reply to Alexander Graf
Quoted 5 lines · Alexander Graf

Multiboot passes options to the option rom using the fw_cfg device.
Right now, that device is local to the bochs_bios_init function.

Let's change that and expose it to env, so everyone may put data in there.

Env is a wrong place for device data.

#11 lore raw

Re: [Qemu-devel] [PATCH 2/4] Expose fw_cfg

Quoted 8 lines · Blue Swirl
Quoted 5 lines · Alexander Graf

Multiboot passes options to the option rom using the fw_cfg device. Right now, that device is local to the bochs_bios_init function.

Let's change that and expose it to env, so everyone may put data in there.

Env is a wrong place for device data.

So what is the right place? Last time I checked there wasn't anything like a global pc machine state struct, but I could be wrong.

Alex

#12 lore raw

Re: [Qemu-devel] [PATCH 2/4] Expose fw_cfg

Quoted 7 lines · Alexander Graf
Quoted 4 lines · Blue Swirl
Quoted 3 lines · Alexander Graf

Multiboot passes options to the option rom using the fw_cfg device. Right now, that device is local to the bochs_bios_init function.

Quoted 6 lines
Quoted 4 lines
Quoted 2 lines

Let's change that and expose it to env, so everyone may put data in there.

Env is a wrong place for device data.

So what is the right place? Last time I checked there wasn't anything like a global pc machine state struct, but I could be wrong.

Return fw_cfg from bochs_bios_init, then pass it to the kernel loading functions.

Regards,

Anthony Liguori

Quoted 3 lines

Alex