v86 0.3.6 → 0.4.0

package/bios/seabios/src/fw/romfile_loader.c

@@ -0,0 +1,259 @@
+#include "romfile_loader.h"
+#include "byteorder.h" // leXX_to_cpu/cpu_to_leXX
+#include "util.h" // checksum
+#include "string.h" // strcmp
+#include "romfile.h" // struct romfile_s
+#include "malloc.h" // Zone*, _malloc
+#include "list.h" // struct hlist_node
+#include "output.h" // warn_*
+#include "paravirt.h" // qemu_cfg_write_file
+
+struct romfile_loader_file {
+    struct romfile_s *file;
+    void *data;
+};
+struct romfile_loader_files {
+    int nfiles;
+    struct romfile_loader_file files[];
+};
+
+// Data structures for storing "write pointer" entries for possible replay
+struct romfile_wr_pointer_entry {
+    u64 pointer;
+    u32 offset;
+    u16 key;
+    u8 ptr_size;
+    struct hlist_node node;
+};
+static struct hlist_head romfile_pointer_list;
+
+static struct romfile_loader_file *
+romfile_loader_find(const char *name,
+                    struct romfile_loader_files *files)
+{
+    int i;
+    if (name[ROMFILE_LOADER_FILESZ - 1])
+        return NULL;
+    for (i = 0; i < files->nfiles; ++i)
+        if (!strcmp(files->files[i].file->name, name))
+            return &files->files[i];
+    return NULL;
+}
+
+// Replay "write pointer" entries back to QEMU
+void romfile_fw_cfg_resume(void)
+{
+    if (!CONFIG_QEMU)
+        return;
+
+    struct romfile_wr_pointer_entry *entry;
+    hlist_for_each_entry(entry, &romfile_pointer_list, node) {
+        qemu_cfg_write_file_simple(&entry->pointer, entry->key,
+                                   entry->offset, entry->ptr_size);
+    }
+}
+
+static void romfile_loader_allocate(struct romfile_loader_entry_s *entry,
+                                    struct romfile_loader_files *files)
+{
+    struct zone_s *zone;
+    struct romfile_loader_file *file = &files->files[files->nfiles];
+    void *data;
+    int ret;
+    unsigned alloc_align = le32_to_cpu(entry->alloc.align);
+
+    if (alloc_align & (alloc_align - 1))
+        goto err;
+
+    switch (entry->alloc.zone) {
+        case ROMFILE_LOADER_ALLOC_ZONE_HIGH:
+            zone = &ZoneHigh;
+            break;
+        case ROMFILE_LOADER_ALLOC_ZONE_FSEG:
+            zone = &ZoneFSeg;
+            break;
+        default:
+            goto err;
+    }
+    if (alloc_align < MALLOC_MIN_ALIGN)
+        alloc_align = MALLOC_MIN_ALIGN;
+    if (entry->alloc.file[ROMFILE_LOADER_FILESZ - 1])
+        goto err;
+    file->file = romfile_find(entry->alloc.file);
+    if (!file->file || !file->file->size)
+        return;
+    data = _malloc(zone, file->file->size, alloc_align);
+    if (!data) {
+        warn_noalloc();
+        return;
+    }
+    ret = file->file->copy(file->file, data, file->file->size);
+    if (ret != file->file->size)
+        goto file_err;
+    file->data = data;
+    files->nfiles++;
+    return;
+
+file_err:
+    free(data);
+err:
+    warn_internalerror();
+}
+
+static void romfile_loader_add_pointer(struct romfile_loader_entry_s *entry,
+                                       struct romfile_loader_files *files)
+{
+    struct romfile_loader_file *dest_file;
+    struct romfile_loader_file *src_file;
+    unsigned offset = le32_to_cpu(entry->pointer.offset);
+    u64 pointer = 0;
+
+    dest_file = romfile_loader_find(entry->pointer.dest_file, files);
+    src_file = romfile_loader_find(entry->pointer.src_file, files);
+
+    if (!dest_file || !src_file || !dest_file->data || !src_file->data ||
+        offset + entry->pointer.size < offset ||
+        offset + entry->pointer.size > dest_file->file->size ||
+        entry->pointer.size < 1 || entry->pointer.size > 8 ||
+        entry->pointer.size & (entry->pointer.size - 1))
+        goto err;
+
+    memcpy(&pointer, dest_file->data + offset, entry->pointer.size);
+    pointer = le64_to_cpu(pointer);
+    pointer += (unsigned long)src_file->data;
+    pointer = cpu_to_le64(pointer);
+    memcpy(dest_file->data + offset, &pointer, entry->pointer.size);
+
+    return;
+err:
+    warn_internalerror();
+}
+
+static void romfile_loader_add_checksum(struct romfile_loader_entry_s *entry,
+                                        struct romfile_loader_files *files)
+{
+    struct romfile_loader_file *file;
+    unsigned offset = le32_to_cpu(entry->cksum.offset);
+    unsigned start = le32_to_cpu(entry->cksum.start);
+    unsigned len = le32_to_cpu(entry->cksum.length);
+    u8 *data;
+
+    file = romfile_loader_find(entry->cksum.file, files);
+
+    if (!file || !file->data || offset >= file->file->size ||
+        start + len < start || start + len > file->file->size)
+        goto err;
+
+    data = file->data + offset;
+    *data -= checksum(file->data + start, len);
+
+    return;
+err:
+    warn_internalerror();
+}
+
+static void romfile_loader_write_pointer(struct romfile_loader_entry_s *entry,
+                                         struct romfile_loader_files *files)
+{
+    struct romfile_s *dest_file;
+    struct romfile_loader_file *src_file;
+    unsigned dst_offset = le32_to_cpu(entry->wr_pointer.dst_offset);
+    unsigned src_offset = le32_to_cpu(entry->wr_pointer.src_offset);
+    u64 pointer = 0;
+
+    /* Writing back to a file that may not be loaded in RAM */
+    dest_file = romfile_find(entry->wr_pointer.dest_file);
+    src_file = romfile_loader_find(entry->wr_pointer.src_file, files);
+
+    if (!dest_file || !src_file || !src_file->data ||
+        dst_offset + entry->wr_pointer.size < dst_offset ||
+        dst_offset + entry->wr_pointer.size > dest_file->size ||
+        src_offset >= src_file->file->size ||
+        entry->wr_pointer.size < 1 || entry->wr_pointer.size > 8 ||
+        entry->wr_pointer.size & (entry->wr_pointer.size - 1)) {
+        goto err;
+    }
+
+    pointer = (unsigned long)src_file->data + src_offset;
+    /* Make sure the pointer fits within wr_pointer.size */
+    if ((entry->wr_pointer.size != sizeof(u64)) &&
+        ((pointer >> (entry->wr_pointer.size * 8)) > 0)) {
+        goto err;
+    }
+    pointer = cpu_to_le64(pointer);
+
+    /* Only supported on QEMU */
+    if (qemu_cfg_write_file(&pointer, dest_file, dst_offset,
+                            entry->wr_pointer.size) != entry->wr_pointer.size) {
+        goto err;
+    }
+
+    /* Store the info so it can replayed later if necessary */
+    struct romfile_wr_pointer_entry *store = malloc_high(sizeof(*store));
+    if (!store) {
+        warn_noalloc();
+        return;
+    }
+    store->pointer = pointer;
+    store->key = qemu_get_romfile_key(dest_file);
+    store->offset = dst_offset;
+    store->ptr_size = entry->wr_pointer.size;
+    hlist_add_head(&store->node, &romfile_pointer_list);
+
+    return;
+ err:
+    warn_internalerror();
+}
+
+int romfile_loader_execute(const char *name)
+{
+    struct romfile_loader_entry_s *entry;
+    int size, offset = 0, nfiles;
+    struct romfile_loader_files *files;
+    void *data = romfile_loadfile(name, &size);
+    if (!data)
+        return -1;
+
+    if (size % sizeof(*entry)) {
+        warn_internalerror();
+        goto err;
+    }
+
+    /* (over)estimate the number of files to load. */
+    nfiles = size / sizeof(*entry);
+    files = malloc_tmp(sizeof(*files) + nfiles * sizeof(files->files[0]));
+    if (!files) {
+        warn_noalloc();
+        goto err;
+    }
+    files->nfiles = 0;
+
+    for (offset = 0; offset < size; offset += sizeof(*entry)) {
+        entry = data + offset;
+        switch (le32_to_cpu(entry->command)) {
+                case ROMFILE_LOADER_COMMAND_ALLOCATE:
+                        romfile_loader_allocate(entry, files);
+                        break;
+                case ROMFILE_LOADER_COMMAND_ADD_POINTER:
+                        romfile_loader_add_pointer(entry, files);
+                        break;
+                case ROMFILE_LOADER_COMMAND_ADD_CHECKSUM:
+                        romfile_loader_add_checksum(entry, files);
+                        break;
+                case ROMFILE_LOADER_COMMAND_WRITE_POINTER:
+                        romfile_loader_write_pointer(entry, files);
+                        break;
+                default:
+                        /* Skip commands that we don't recognize. */
+                        break;
+        }
+    }
+
+    free(files);
+    free(data);
+    return 0;
+
+err:
+    free(data);
+    return -1;
+}

package/bios/seabios/src/fw/romfile_loader.h

@@ -0,0 +1,91 @@
+#ifndef __ROMFILE_LOADER_H
+#define __ROMFILE_LOADER_H
+
+#include "types.h" // u8
+#include "util.h" // romfile_s
+
+#define ROMFILE_LOADER_FILESZ 56
+
+/* ROM file linker/loader interface. Linker uses little endian format */
+struct romfile_loader_entry_s {
+    u32 command;
+    union {
+        /*
+         * COMMAND_ALLOCATE - allocate a table from @alloc.file
+         * subject to @alloc.align alignment (must be power of 2)
+         * and @alloc.zone (can be HIGH or FSEG) requirements.
+         *
+         * Must appear exactly once for each file, and before
+         * this file is referenced by any other command.
+         */
+        struct {
+            char file[ROMFILE_LOADER_FILESZ];
+            u32 align;
+            u8 zone;
+        } alloc;
+
+        /*
+         * COMMAND_ADD_POINTER - patch the table (originating from
+         * @dest_file) at @pointer.offset, by adding a pointer to the table
+         * originating from @src_file. 1,2,4 or 8 byte unsigned
+         * addition is used depending on @pointer.size.
+         */
+        struct {
+            char dest_file[ROMFILE_LOADER_FILESZ];
+            char src_file[ROMFILE_LOADER_FILESZ];
+            u32 offset;
+            u8 size;
+        } pointer;
+
+        /*
+         * COMMAND_ADD_CHECKSUM - calculate checksum of the range specified by
+         * @cksum.start and @cksum.length fields,
+         * and then add the value at @cksum_offset.
+         * Checksum simply sums -X for each byte X in the range
+         * using 8-bit math.
+         */
+        struct {
+            char file[ROMFILE_LOADER_FILESZ];
+            u32 offset;
+            u32 start;
+            u32 length;
+        } cksum;
+
+        /*
+         * COMMAND_WRITE_POINTER - Write back to a host file via DMA,
+         * @wr_pointer.dest_file at offset @wr_pointer.dst_offset, a pointer
+         * to the table originating from @wr_pointer.src_file at offset
+         * @wr_pointer.src_offset.
+         * 1,2,4 or 8 byte unsigned addition is used depending on
+         * @wr_pointer.size.
+         */
+        struct {
+            char dest_file[ROMFILE_LOADER_FILESZ];
+            char src_file[ROMFILE_LOADER_FILESZ];
+            u32 dst_offset;
+            u32 src_offset;
+            u8 size;
+        } wr_pointer;
+
+        /* padding */
+        char pad[124];
+    };
+};
+
+enum {
+    ROMFILE_LOADER_COMMAND_ALLOCATE      = 0x1,
+    ROMFILE_LOADER_COMMAND_ADD_POINTER   = 0x2,
+    ROMFILE_LOADER_COMMAND_ADD_CHECKSUM  = 0x3,
+    ROMFILE_LOADER_COMMAND_WRITE_POINTER = 0x4,
+};
+
+enum {
+    ROMFILE_LOADER_ALLOC_ZONE_HIGH = 0x1,
+    ROMFILE_LOADER_ALLOC_ZONE_FSEG = 0x2,
+};
+
+int romfile_loader_execute(const char *name);
+
+void romfile_fw_cfg_resume(void);
+
+#endif

package/bios/seabios/src/fw/shadow.c

@@ -0,0 +1,208 @@
+// Support for enabling/disabling BIOS ram shadowing.
+//
+// Copyright (C) 2008-2010  Kevin O'Connor <kevin@koconnor.net>
+// Copyright (C) 2006 Fabrice Bellard
+//
+// This file may be distributed under the terms of the GNU LGPLv3 license.
+
+#include "config.h" // CONFIG_*
+#include "dev-q35.h" // PCI_VENDOR_ID_INTEL
+#include "dev-piix.h" // I440FX_PAM0
+#include "hw/pci.h" // pci_config_writeb
+#include "hw/pci_ids.h" // PCI_VENDOR_ID_INTEL
+#include "hw/pci_regs.h" // PCI_VENDOR_ID
+#include "malloc.h" // rom_get_last
+#include "output.h" // dprintf
+#include "paravirt.h" // runningOnXen
+#include "string.h" // memset
+#include "util.h" // make_bios_writable
+#include "x86.h" // wbinvd
+
+// On the emulators, the bios at 0xf0000 is also at 0xffff0000
+#define BIOS_SRC_OFFSET 0xfff00000
+
+union pamdata_u {
+    u8 data8[8];
+    u32 data32[2];
+};
+
+// Enable shadowing and copy bios.
+static void
+__make_bios_writable_intel(u16 bdf, u32 pam0)
+{
+    // Read in current PAM settings from pci config space
+    union pamdata_u pamdata;
+    pamdata.data32[0] = pci_config_readl(bdf, ALIGN_DOWN(pam0, 4));
+    pamdata.data32[1] = pci_config_readl(bdf, ALIGN_DOWN(pam0, 4) + 4);
+    u8 *pam = &pamdata.data8[pam0 & 0x03];
+
+    // Make ram from 0xc0000-0xf0000 writable
+    int i;
+    for (i=0; i<6; i++)
+        pam[i + 1] = 0x33;
+
+    // Make ram from 0xf0000-0x100000 writable
+    int ram_present = pam[0] & 0x10;
+    pam[0] = 0x30;
+
+    // Write PAM settings back to pci config space
+    pci_config_writel(bdf, ALIGN_DOWN(pam0, 4), pamdata.data32[0]);
+    pci_config_writel(bdf, ALIGN_DOWN(pam0, 4) + 4, pamdata.data32[1]);
+
+    if (!ram_present)
+        // Copy bios.
+        memcpy(VSYMBOL(code32flat_start)
+               , VSYMBOL(code32flat_start) + BIOS_SRC_OFFSET
+               , SYMBOL(code32flat_end) - SYMBOL(code32flat_start));
+}
+
+static void
+make_bios_writable_intel(u16 bdf, u32 pam0)
+{
+    int reg = pci_config_readb(bdf, pam0);
+    if (!(reg & 0x10)) {
+        // QEMU doesn't fully implement the piix shadow capabilities -
+        // if ram isn't backing the bios segment when shadowing is
+        // disabled, the code itself won't be in memory.  So, run the
+        // code from the high-memory flash location.
+        u32 pos = (u32)__make_bios_writable_intel + BIOS_SRC_OFFSET;
+        void (*func)(u16 bdf, u32 pam0) = (void*)pos;
+        func(bdf, pam0);
+        return;
+    }
+    // Ram already present - just enable writes
+    __make_bios_writable_intel(bdf, pam0);
+}
+
+static void
+make_bios_readonly_intel(u16 bdf, u32 pam0)
+{
+    // Flush any pending writes before locking memory.
+    wbinvd();
+
+    // Read in current PAM settings from pci config space
+    union pamdata_u pamdata;
+    pamdata.data32[0] = pci_config_readl(bdf, ALIGN_DOWN(pam0, 4));
+    pamdata.data32[1] = pci_config_readl(bdf, ALIGN_DOWN(pam0, 4) + 4);
+    u8 *pam = &pamdata.data8[pam0 & 0x03];
+
+    // Write protect roms from 0xc0000-0xf0000
+    u32 romlast = BUILD_BIOS_ADDR, rommax = BUILD_BIOS_ADDR;
+    if (CONFIG_WRITABLE_UPPERMEMORY)
+        romlast = rom_get_last();
+    if (CONFIG_MALLOC_UPPERMEMORY)
+        rommax = rom_get_max();
+    int i;
+    for (i=0; i<6; i++) {
+        u32 mem = BUILD_ROM_START + i * 32*1024;
+        if (romlast < mem + 16*1024 || rommax < mem + 32*1024) {
+            if (romlast >= mem && rommax >= mem + 16*1024)
+                pam[i + 1] = 0x31;
+            break;
+        }
+        pam[i + 1] = 0x11;
+    }
+
+    // Write protect 0xf0000-0x100000
+    pam[0] = 0x10;
+
+    // Write PAM settings back to pci config space
+    pci_config_writel(bdf, ALIGN_DOWN(pam0, 4), pamdata.data32[0]);
+    pci_config_writel(bdf, ALIGN_DOWN(pam0, 4) + 4, pamdata.data32[1]);
+}
+
+static int ShadowBDF = -1;
+
+// Make the 0xc0000-0x100000 area read/writable.
+void
+make_bios_writable(void)
+{
+    if (!CONFIG_QEMU || runningOnXen())
+        return;
+
+    dprintf(3, "enabling shadow ram\n");
+
+    // At this point, statically allocated variables can't be written,
+    // so do this search manually.
+    int bdf;
+    foreachbdf(bdf, 0) {
+        u32 vendev = pci_config_readl(bdf, PCI_VENDOR_ID);
+        u16 vendor = vendev & 0xffff, device = vendev >> 16;
+        if (vendor == PCI_VENDOR_ID_INTEL
+            && device == PCI_DEVICE_ID_INTEL_82441) {
+            make_bios_writable_intel(bdf, I440FX_PAM0);
+            code_mutable_preinit();
+            ShadowBDF = bdf;
+            return;
+        }
+        if (vendor == PCI_VENDOR_ID_INTEL
+            && device == PCI_DEVICE_ID_INTEL_Q35_MCH) {
+            make_bios_writable_intel(bdf, Q35_HOST_BRIDGE_PAM0);
+            code_mutable_preinit();
+            ShadowBDF = bdf;
+            return;
+        }
+    }
+    dprintf(1, "Unable to unlock ram - bridge not found\n");
+}
+
+// Make the BIOS code segment area (0xf0000) read-only.
+void
+make_bios_readonly(void)
+{
+    if (!CONFIG_QEMU || runningOnXen())
+        return;
+    dprintf(3, "locking shadow ram\n");
+
+    if (ShadowBDF < 0) {
+        dprintf(1, "Unable to lock ram - bridge not found\n");
+        return;
+    }
+
+    u16 device = pci_config_readw(ShadowBDF, PCI_DEVICE_ID);
+    if (device == PCI_DEVICE_ID_INTEL_82441)
+        make_bios_readonly_intel(ShadowBDF, I440FX_PAM0);
+    else
+        make_bios_readonly_intel(ShadowBDF, Q35_HOST_BRIDGE_PAM0);
+}
+
+void
+qemu_reboot(void)
+{
+    if (!CONFIG_QEMU || runningOnXen())
+        return;
+    // QEMU doesn't map 0xc0000-0xfffff back to the original rom on a
+    // reset, so do that manually before invoking a hard reset.
+    void *flash = (void*)BIOS_SRC_OFFSET;
+    u32 hrp = (u32)&HaveRunPost;
+    if (readl(flash + hrp)) {
+        // There isn't a pristine copy of the BIOS at 0xffff0000 to copy
+        if (HaveRunPost == 3) {
+            // In a reboot loop.  Try to shutdown the machine instead.
+            dprintf(1, "Unable to hard-reboot machine - attempting shutdown.\n");
+            apm_shutdown();
+        }
+        make_bios_writable();
+        HaveRunPost = 3;
+    } else {
+        // Copy the BIOS making sure to only reset HaveRunPost at end
+        make_bios_writable();
+        u32 cstart = SYMBOL(code32flat_start), cend = SYMBOL(code32flat_end);
+        memcpy((void*)cstart, flash + cstart, hrp - cstart);
+        memcpy((void*)hrp + 4, flash + hrp + 4, cend - (hrp + 4));
+        barrier();
+        HaveRunPost = 0;
+        barrier();
+    }
+
+    // Request a QEMU system reset.  Do the reset in this function as
+    // the BIOS code was overwritten above and not all BIOS
+    // functionality may be available.
+
+    // Attempt PCI style reset
+    outb(0x02, PORT_PCI_REBOOT);
+    outb(0x06, PORT_PCI_REBOOT);
+
+    // Next try triple faulting the CPU to force a reset
+    asm volatile("int3");
+}