util: move declarations out of qemu-common.h

[qemu.git] / hw / core / loader.c

diff --git a/hw/core/loader.c b/hw/core/loader.c
index 2bf6b8ff856022b2017cc75d79329b864faa21a0..6b949fe44ffa88e28762380112bbd40efde346d2 100644 (file)
--- a/hw/core/loader.c
+++ b/hw/core/loader.c
@@ -42,6 +42,8 @@
  * with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
  * with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 

+#include "qemu/osdep.h"
+#include "qapi/error.h"

 #include "hw/hw.h"
 #include "disas/disas.h"
 #include "monitor/monitor.h"
 #include "hw/hw.h"
 #include "disas/disas.h"
 #include "monitor/monitor.h"


@@ -51,12 +53,11 @@
 #include "hw/nvram/fw_cfg.h"
 #include "exec/memory.h"
 #include "exec/address-spaces.h"
 #include "hw/nvram/fw_cfg.h"
 #include "exec/memory.h"
 #include "exec/address-spaces.h"

+#include "hw/boards.h"
+#include "qemu/cutils.h"

 
 #include <zlib.h>
 
 
 #include <zlib.h>
 

-bool option_rom_has_mr = false;
-bool rom_file_has_mr = true;
-

 static int roms_loaded;
 
 /* return the size or -1 if error */
 static int roms_loaded;
 
 /* return the size or -1 if error */


@@ -80,6 +81,13 @@ int load_image(const char *filename, uint8_t *addr)
     if (fd < 0)
         return -1;
     size = lseek(fd, 0, SEEK_END);
     if (fd < 0)
         return -1;
     size = lseek(fd, 0, SEEK_END);

+    if (size == -1) {
+        fprintf(stderr, "file %-20s: get size error: %s\n",
+                filename, strerror(errno));
+        close(fd);
+        return -1;
+    }
+

     lseek(fd, 0, SEEK_SET);
     if (read(fd, addr, size) != size) {
         close(fd);
     lseek(fd, 0, SEEK_SET);
     if (read(fd, addr, size) != size) {
         close(fd);


@@ -89,6 +97,27 @@ int load_image(const char *filename, uint8_t *addr)
     return size;
 }
 
     return size;
 }
 

+/* return the size or -1 if error */
+ssize_t load_image_size(const char *filename, void *addr, size_t size)
+{
+    int fd;
+    ssize_t actsize;
+
+    fd = open(filename, O_RDONLY | O_BINARY);
+    if (fd < 0) {
+        return -1;
+    }
+
+    actsize = read(fd, addr, size);
+    if (actsize < 0) {
+        close(fd);
+        return -1;
+    }
+    close(fd);
+
+    return actsize;
+}
+

 /* read()-like version */
 ssize_t read_targphys(const char *name,
                       int fd, hwaddr dst_addr, size_t nbytes)
 /* read()-like version */
 ssize_t read_targphys(const char *name,
                       int fd, hwaddr dst_addr, size_t nbytes)


@@ -120,6 +149,28 @@ int load_image_targphys(const char *filename,
     return size;
 }
 
     return size;
 }
 

+int load_image_mr(const char *filename, MemoryRegion *mr)
+{
+    int size;
+
+    if (!memory_access_is_direct(mr, false)) {
+        /* Can only load an image into RAM or ROM */
+        return -1;
+    }
+
+    size = get_image_size(filename);
+
+    if (size > memory_region_size(mr)) {
+        return -1;
+    }
+    if (size > 0) {
+        if (rom_add_file_mr(filename, mr, -1) < 0) {
+            return -1;
+        }
+    }
+    return size;
+}
+

 void pstrcpy_targphys(const char *name, hwaddr dest, int buf_size,
                       const char *source)
 {
 void pstrcpy_targphys(const char *name, hwaddr dest, int buf_size,
                       const char *source)
 {


@@ -239,7 +290,7 @@ int load_aout(const char *filename, hwaddr addr, int max_sz,
 
 /* ELF loader */
 
 
 /* ELF loader */
 

-static void *load_at(int fd, int offset, int size)
+static void *load_at(int fd, off_t offset, size_t size)

 {
     void *ptr;
     if (lseek(fd, offset, SEEK_SET) < 0)
 {
     void *ptr;
     if (lseek(fd, offset, SEEK_SET) < 0)


@@ -269,6 +320,7 @@ static void *load_at(int fd, int offset, int size)
 #undef elf_phdr
 #undef elf_shdr
 #undef elf_sym
 #undef elf_phdr
 #undef elf_shdr
 #undef elf_sym

+#undef elf_rela

 #undef elf_note
 #undef elf_word
 #undef elf_sword
 #undef elf_note
 #undef elf_word
 #undef elf_sword


@@ -279,6 +331,7 @@ static void *load_at(int fd, int offset, int size)
 #define elf_note       elf64_note
 #define elf_shdr       elf64_shdr
 #define elf_sym                elf64_sym
 #define elf_note       elf64_note
 #define elf_shdr       elf64_shdr
 #define elf_sym                elf64_sym

+#define elf_rela        elf64_rela

 #define elf_word        uint64_t
 #define elf_sword        int64_t
 #define bswapSZs       bswap64s
 #define elf_word        uint64_t
 #define elf_sword        int64_t
 #define bswapSZs       bswap64s


@@ -303,10 +356,66 @@ const char *load_elf_strerror(int error)
     }
 }
 
     }
 }
 

+void load_elf_hdr(const char *filename, void *hdr, bool *is64, Error **errp)
+{
+    int fd;
+    uint8_t e_ident_local[EI_NIDENT];
+    uint8_t *e_ident;
+    size_t hdr_size, off;
+    bool is64l;
+
+    if (!hdr) {
+        hdr = e_ident_local;
+    }
+    e_ident = hdr;
+
+    fd = open(filename, O_RDONLY | O_BINARY);
+    if (fd < 0) {
+        error_setg_errno(errp, errno, "Failed to open file: %s", filename);
+        return;
+    }
+    if (read(fd, hdr, EI_NIDENT) != EI_NIDENT) {
+        error_setg_errno(errp, errno, "Failed to read file: %s", filename);
+        goto fail;
+    }
+    if (e_ident[0] != ELFMAG0 ||
+        e_ident[1] != ELFMAG1 ||
+        e_ident[2] != ELFMAG2 ||
+        e_ident[3] != ELFMAG3) {
+        error_setg(errp, "Bad ELF magic");
+        goto fail;
+    }
+
+    is64l = e_ident[EI_CLASS] == ELFCLASS64;
+    hdr_size = is64l ? sizeof(Elf64_Ehdr) : sizeof(Elf32_Ehdr);
+    if (is64) {
+        *is64 = is64l;
+    }
+
+    off = EI_NIDENT;
+    while (hdr != e_ident_local && off < hdr_size) {
+        size_t br = read(fd, hdr + off, hdr_size - off);
+        switch (br) {
+        case 0:
+            error_setg(errp, "File too short: %s", filename);
+            goto fail;
+        case -1:
+            error_setg_errno(errp, errno, "Failed to read file: %s",
+                             filename);
+            goto fail;
+        }
+        off += br;
+    }
+
+fail:
+    close(fd);
+}
+

 /* return < 0 if error, otherwise the number of bytes loaded in memory */
 int load_elf(const char *filename, uint64_t (*translate_fn)(void *, uint64_t),
              void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr,
 /* return < 0 if error, otherwise the number of bytes loaded in memory */
 int load_elf(const char *filename, uint64_t (*translate_fn)(void *, uint64_t),
              void *translate_opaque, uint64_t *pentry, uint64_t *lowaddr,

-             uint64_t *highaddr, int big_endian, int elf_machine, int clear_lsb)
+             uint64_t *highaddr, int big_endian, int elf_machine,
+             int clear_lsb, int data_swab)

 {
     int fd, data_order, target_data_order, must_swab, ret = ELF_LOAD_FAILED;
     uint8_t e_ident[EI_NIDENT];
 {
     int fd, data_order, target_data_order, must_swab, ret = ELF_LOAD_FAILED;
     uint8_t e_ident[EI_NIDENT];


@@ -345,10 +454,12 @@ int load_elf(const char *filename, uint64_t (*translate_fn)(void *, uint64_t),
     lseek(fd, 0, SEEK_SET);
     if (e_ident[EI_CLASS] == ELFCLASS64) {
         ret = load_elf64(filename, fd, translate_fn, translate_opaque, must_swab,
     lseek(fd, 0, SEEK_SET);
     if (e_ident[EI_CLASS] == ELFCLASS64) {
         ret = load_elf64(filename, fd, translate_fn, translate_opaque, must_swab,

-                         pentry, lowaddr, highaddr, elf_machine, clear_lsb);
+                         pentry, lowaddr, highaddr, elf_machine, clear_lsb,
+                         data_swab);

     } else {
         ret = load_elf32(filename, fd, translate_fn, translate_opaque, must_swab,
     } else {
         ret = load_elf32(filename, fd, translate_fn, translate_opaque, must_swab,

-                         pentry, lowaddr, highaddr, elf_machine, clear_lsb);
+                         pentry, lowaddr, highaddr, elf_machine, clear_lsb,
+                         data_swab);

     }
 
  fail:
     }
 
  fail:


@@ -456,7 +567,9 @@ static ssize_t gunzip(void *dst, size_t dstlen, uint8_t *src,
 
 /* Load a U-Boot image.  */
 static int load_uboot_image(const char *filename, hwaddr *ep, hwaddr *loadaddr,
 
 /* Load a U-Boot image.  */
 static int load_uboot_image(const char *filename, hwaddr *ep, hwaddr *loadaddr,

-                            int *is_linux, uint8_t image_type)
+                            int *is_linux, uint8_t image_type,
+                            uint64_t (*translate_fn)(void *, uint64_t),
+                            void *translate_opaque)

 {
     int fd;
     int size;
 {
     int fd;
     int size;


@@ -490,6 +603,9 @@ static int load_uboot_image(const char *filename, hwaddr *ep, hwaddr *loadaddr,
     switch (hdr->ih_type) {
     case IH_TYPE_KERNEL:
         address = hdr->ih_load;
     switch (hdr->ih_type) {
     case IH_TYPE_KERNEL:
         address = hdr->ih_load;

+        if (translate_fn) {
+            address = translate_fn(translate_opaque, address);
+        }

         if (loadaddr) {
             *loadaddr = hdr->ih_load;
         }
         if (loadaddr) {
             *loadaddr = hdr->ih_load;
         }


@@ -559,22 +675,85 @@ static int load_uboot_image(const char *filename, hwaddr *ep, hwaddr *loadaddr,
     ret = hdr->ih_size;
 
 out:
     ret = hdr->ih_size;
 
 out:

-    if (data)
-        g_free(data);
+    g_free(data);

     close(fd);
     return ret;
 }
 
 int load_uimage(const char *filename, hwaddr *ep, hwaddr *loadaddr,
     close(fd);
     return ret;
 }
 
 int load_uimage(const char *filename, hwaddr *ep, hwaddr *loadaddr,

-                int *is_linux)
+                int *is_linux,
+                uint64_t (*translate_fn)(void *, uint64_t),
+                void *translate_opaque)

 {
 {

-    return load_uboot_image(filename, ep, loadaddr, is_linux, IH_TYPE_KERNEL);
+    return load_uboot_image(filename, ep, loadaddr, is_linux, IH_TYPE_KERNEL,
+                            translate_fn, translate_opaque);

 }
 
 /* Load a ramdisk.  */
 int load_ramdisk(const char *filename, hwaddr addr, uint64_t max_sz)
 {
 }
 
 /* Load a ramdisk.  */
 int load_ramdisk(const char *filename, hwaddr addr, uint64_t max_sz)
 {

-    return load_uboot_image(filename, NULL, &addr, NULL, IH_TYPE_RAMDISK);
+    return load_uboot_image(filename, NULL, &addr, NULL, IH_TYPE_RAMDISK,
+                            NULL, NULL);
+}
+
+/* Load a gzip-compressed kernel to a dynamically allocated buffer. */
+int load_image_gzipped_buffer(const char *filename, uint64_t max_sz,
+                              uint8_t **buffer)
+{
+    uint8_t *compressed_data = NULL;
+    uint8_t *data = NULL;
+    gsize len;
+    ssize_t bytes;
+    int ret = -1;
+
+    if (!g_file_get_contents(filename, (char **) &compressed_data, &len,
+                             NULL)) {
+        goto out;
+    }
+
+    /* Is it a gzip-compressed file? */
+    if (len < 2 ||
+        compressed_data[0] != 0x1f ||
+        compressed_data[1] != 0x8b) {
+        goto out;
+    }
+
+    if (max_sz > LOAD_IMAGE_MAX_GUNZIP_BYTES) {
+        max_sz = LOAD_IMAGE_MAX_GUNZIP_BYTES;
+    }
+
+    data = g_malloc(max_sz);
+    bytes = gunzip(data, max_sz, compressed_data, len);
+    if (bytes < 0) {
+        fprintf(stderr, "%s: unable to decompress gzipped kernel file\n",
+                filename);
+        goto out;
+    }
+
+    /* trim to actual size and return to caller */
+    *buffer = g_realloc(data, bytes);
+    ret = bytes;
+    /* ownership has been transferred to caller */
+    data = NULL;
+
+ out:
+    g_free(compressed_data);
+    g_free(data);
+    return ret;
+}
+
+/* Load a gzip-compressed kernel. */
+int load_image_gzipped(const char *filename, hwaddr addr, uint64_t max_sz)
+{
+    int bytes;
+    uint8_t *data;
+
+    bytes = load_image_gzipped_buffer(filename, max_sz, &data);
+    if (bytes != -1) {
+        rom_add_blob_fixed(filename, data, bytes, addr);
+        g_free(data);
+    }
+    return bytes;

 }
 
 /*
 }
 
 /*


@@ -627,12 +806,22 @@ static void rom_insert(Rom *rom)
     QTAILQ_INSERT_TAIL(&roms, rom, next);
 }
 
     QTAILQ_INSERT_TAIL(&roms, rom, next);
 }
 

+static void fw_cfg_resized(const char *id, uint64_t length, void *host)
+{
+    if (fw_cfg) {
+        fw_cfg_modify_file(fw_cfg, id + strlen("/rom@"), host, length);
+    }
+}
+

 static void *rom_set_mr(Rom *rom, Object *owner, const char *name)
 {
     void *data;
 
     rom->mr = g_malloc(sizeof(*rom->mr));
 static void *rom_set_mr(Rom *rom, Object *owner, const char *name)
 {
     void *data;
 
     rom->mr = g_malloc(sizeof(*rom->mr));

-    memory_region_init_ram(rom->mr, owner, name, rom->datasize);
+    memory_region_init_resizeable_ram(rom->mr, owner, name,
+                                      rom->datasize, rom->romsize,
+                                      fw_cfg_resized,
+                                      &error_fatal);

     memory_region_set_readonly(rom->mr, true);
     vmstate_register_ram_global(rom->mr);
 
     memory_region_set_readonly(rom->mr, true);
     vmstate_register_ram_global(rom->mr);
 


@@ -644,8 +833,9 @@ static void *rom_set_mr(Rom *rom, Object *owner, const char *name)
 
 int rom_add_file(const char *file, const char *fw_dir,
                  hwaddr addr, int32_t bootindex,
 
 int rom_add_file(const char *file, const char *fw_dir,
                  hwaddr addr, int32_t bootindex,

-                 bool option_rom)
+                 bool option_rom, MemoryRegion *mr)

 {
 {

+    MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());

     Rom *rom;
     int rc, fd = -1;
     char devpath[100];
     Rom *rom;
     int rc, fd = -1;
     char devpath[100];


@@ -670,6 +860,12 @@ int rom_add_file(const char *file, const char *fw_dir,
     }
     rom->addr     = addr;
     rom->romsize  = lseek(fd, 0, SEEK_END);
     }
     rom->addr     = addr;
     rom->romsize  = lseek(fd, 0, SEEK_END);

+    if (rom->romsize == -1) {
+        fprintf(stderr, "rom: file %-20s: get size error: %s\n",
+                rom->name, strerror(errno));
+        goto err;
+    }
+

     rom->datasize = rom->romsize;
     rom->data     = g_malloc0(rom->datasize);
     lseek(fd, 0, SEEK_SET);
     rom->datasize = rom->romsize;
     rom->data     = g_malloc0(rom->datasize);
     lseek(fd, 0, SEEK_SET);


@@ -696,7 +892,7 @@ int rom_add_file(const char *file, const char *fw_dir,
                  basename);
         snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name);
 
                  basename);
         snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name);
 

-        if ((!option_rom || option_rom_has_mr) && rom_file_has_mr) {
+        if ((!option_rom || mc->option_rom_has_mr) && mc->rom_file_has_mr) {

             data = rom_set_mr(rom, OBJECT(fw_cfg), devpath);
         } else {
             data = rom->data;
             data = rom_set_mr(rom, OBJECT(fw_cfg), devpath);
         } else {
             data = rom->data;


@@ -704,7 +900,12 @@ int rom_add_file(const char *file, const char *fw_dir,
 
         fw_cfg_add_file(fw_cfg, fw_file_name, data, rom->romsize);
     } else {
 
         fw_cfg_add_file(fw_cfg, fw_file_name, data, rom->romsize);
     } else {

-        snprintf(devpath, sizeof(devpath), "/rom@" TARGET_FMT_plx, addr);
+        if (mr) {
+            rom->mr = mr;
+            snprintf(devpath, sizeof(devpath), "/rom@%s", file);
+        } else {
+            snprintf(devpath, sizeof(devpath), "/rom@" TARGET_FMT_plx, addr);
+        }

     }
 
     add_boot_device_path(bootindex, NULL, devpath);
     }
 
     add_boot_device_path(bootindex, NULL, devpath);


@@ -720,37 +921,40 @@ err:
     return -1;
 }
 
     return -1;
 }
 

-void *rom_add_blob(const char *name, const void *blob, size_t len,
-                   hwaddr addr, const char *fw_file_name,
+MemoryRegion *rom_add_blob(const char *name, const void *blob, size_t len,
+                   size_t max_len, hwaddr addr, const char *fw_file_name,

                    FWCfgReadCallback fw_callback, void *callback_opaque)
 {
                    FWCfgReadCallback fw_callback, void *callback_opaque)
 {

+    MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());

     Rom *rom;
     Rom *rom;

-    void *data = NULL;
+    MemoryRegion *mr = NULL;

 
     rom           = g_malloc0(sizeof(*rom));
     rom->name     = g_strdup(name);
     rom->addr     = addr;
 
     rom           = g_malloc0(sizeof(*rom));
     rom->name     = g_strdup(name);
     rom->addr     = addr;

-    rom->romsize  = len;
+    rom->romsize  = max_len ? max_len : len;

     rom->datasize = len;
     rom->data     = g_malloc0(rom->datasize);
     memcpy(rom->data, blob, len);
     rom_insert(rom);
     if (fw_file_name && fw_cfg) {
         char devpath[100];
     rom->datasize = len;
     rom->data     = g_malloc0(rom->datasize);
     memcpy(rom->data, blob, len);
     rom_insert(rom);
     if (fw_file_name && fw_cfg) {
         char devpath[100];

+        void *data;

 
         snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name);
 
 
         snprintf(devpath, sizeof(devpath), "/rom@%s", fw_file_name);
 

-        if (rom_file_has_mr) {
+        if (mc->rom_file_has_mr) {

             data = rom_set_mr(rom, OBJECT(fw_cfg), devpath);
             data = rom_set_mr(rom, OBJECT(fw_cfg), devpath);

+            mr = rom->mr;

         } else {
             data = rom->data;
         }
 
         fw_cfg_add_file_callback(fw_cfg, fw_file_name,
                                  fw_callback, callback_opaque,
         } else {
             data = rom->data;
         }
 
         fw_cfg_add_file_callback(fw_cfg, fw_file_name,
                                  fw_callback, callback_opaque,

-                                 data, rom->romsize);
+                                 data, rom->datasize);

     }
     }

-    return data;
+    return mr;

 }
 
 /* This function is specific for elf program because we don't need to allocate
 }
 
 /* This function is specific for elf program because we don't need to allocate


@@ -775,12 +979,12 @@ int rom_add_elf_program(const char *name, void *data, size_t datasize,
 
 int rom_add_vga(const char *file)
 {
 
 int rom_add_vga(const char *file)
 {

-    return rom_add_file(file, "vgaroms", 0, -1, true);
+    return rom_add_file(file, "vgaroms", 0, -1, true, NULL);

 }
 
 int rom_add_option(const char *file, int32_t bootindex)
 {
 }
 
 int rom_add_option(const char *file, int32_t bootindex)
 {

-    return rom_add_file(file, "genroms", 0, bootindex, true);
+    return rom_add_file(file, "genroms", 0, bootindex, true, NULL);

 }
 
 static void rom_reset(void *unused)
 }
 
 static void rom_reset(void *unused)


@@ -816,7 +1020,7 @@ static void rom_reset(void *unused)
     }
 }
 
     }
 }
 

-int rom_load_all(void)
+int rom_check_and_register_reset(void)

 {
     hwaddr addr = 0;
     MemoryRegionSection section;
 {
     hwaddr addr = 0;
     MemoryRegionSection section;


@@ -840,12 +1044,8 @@ int rom_load_all(void)
         memory_region_unref(section.mr);
     }
     qemu_register_reset(rom_reset, NULL);
         memory_region_unref(section.mr);
     }
     qemu_register_reset(rom_reset, NULL);

-    return 0;
-}
-
-void rom_load_done(void)
-{

     roms_loaded = 1;
     roms_loaded = 1;

+    return 0;

 }
 
 void rom_set_fw(FWCfgState *f)
 }
 
 void rom_set_fw(FWCfgState *f)


@@ -947,7 +1147,7 @@ void *rom_ptr(hwaddr addr)
     return rom->data + (addr - rom->addr);
 }
 
     return rom->data + (addr - rom->addr);
 }
 

-void do_info_roms(Monitor *mon, const QDict *qdict)
+void hmp_info_roms(Monitor *mon, const QDict *qdict)

 {
     Rom *rom;
 
 {
     Rom *rom;
 


@@ -955,7 +1155,7 @@ void do_info_roms(Monitor *mon, const QDict *qdict)
         if (rom->mr) {
             monitor_printf(mon, "%s"
                            " size=0x%06zx name=\"%s\"\n",
         if (rom->mr) {
             monitor_printf(mon, "%s"
                            " size=0x%06zx name=\"%s\"\n",

-                           rom->mr->name,
+                           memory_region_name(rom->mr),

                            rom->romsize,
                            rom->name);
         } else if (!rom->fw_file) {
                            rom->romsize,
                            rom->name);
         } else if (!rom->fw_file) {