fridtjof/qemu-cr16
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

hw/core/loader: capture Error from load_image_targphys

Browse source 
Add Error **errp parameter to load_image_targphys(),
load_image_targphys_as(), and get_image_size() to enable better
error reporting when image loading fails.

Pass NULL for errp in all existing call sites to maintain current
behavior. No functional change intended in this patch.

Suggested-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Reviewed-by: Aditya Gupta <adityag@linux.ibm.com>
Tested-by: Aditya Gupta <adityag@linux.ibm.com>
Signed-off-by: Vishal Chourasia <vishalc@linux.ibm.com>
Message-ID: <20251024130556.1942835-6-vishalc@linux.ibm.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org>
This commit is contained in:
Vishal Chourasia 2025-10-24 18:35:55 +05:30 • committed by Philippe Mathieu-Daudé
parent 77a5b02b5b
commit a9c608904f
51 changed files with 145 additions and 106 deletions
Download patch file Download diff file Expand all files Collapse all files

4
hw/alpha/dp264.c
View file

@ -182,7 +182,7 @@ static void clipper_init(MachineState *machine)
long initrd_base;
int64_t initrd_size;
initrd_size = get_image_size(initrd_filename);
initrd_size = get_image_size(initrd_filename, NULL);
if (initrd_size < 0) {
error_report("could not load initial ram disk '%s'",
initrd_filename);
@ -192,7 +192,7 @@ static void clipper_init(MachineState *machine)
/* Put the initrd image as high in memory as possible. */
initrd_base = (ram_size - initrd_size) & TARGET_PAGE_MASK;
load_image_targphys(initrd_filename, initrd_base,
ram_size - initrd_base);
ram_size - initrd_base, NULL);
address_space_stq(&address_space_memory, param_offset + 0x100,
initrd_base + 0xfffffc0000000000ULL,

2
hw/arm/armv7m.c
View file

@ -611,7 +611,7 @@ void armv7m_load_kernel(ARMCPU *cpu, const char *kernel_filename,
NULL, ELFDATA2LSB, EM_ARM, 1, 0, as);
if (image_size < 0) {
image_size = load_image_targphys_as(kernel_filename, mem_base,
mem_size, as);
mem_size, as, NULL);
}
if (image_size < 0) {
error_report("Could not load kernel '%s'", kernel_filename);

5
hw/arm/boot.c
View file

@ -964,7 +964,8 @@ static void arm_setup_direct_kernel_boot(ARMCPU *cpu,
/* 32-bit ARM */
entry = info->loader_start + KERNEL_LOAD_ADDR;
kernel_size = load_image_targphys_as(info->kernel_filename, entry,
ram_end - KERNEL_LOAD_ADDR, as);
ram_end - KERNEL_LOAD_ADDR, as,
NULL);
is_linux = 1;
if (kernel_size >= 0) {
image_low_addr = entry;
@ -1025,7 +1026,7 @@ static void arm_setup_direct_kernel_boot(ARMCPU *cpu,
info->initrd_start,
ram_end -
info->initrd_start,
as);
as, NULL);
}
if (initrd_size < 0) {
error_report("could not load initrd '%s'",

2
hw/arm/digic_boards.c
View file

@ -97,7 +97,7 @@ static void digic_load_rom(DigicState *s, hwaddr addr,
exit(1);
}
rom_size = load_image_targphys(fn, addr, max_size);
rom_size = load_image_targphys(fn, addr, max_size, NULL);
if (rom_size < 0 || rom_size > max_size) {
error_report("Couldn't load rom image '%s'.", filename);
exit(1);

3
hw/arm/highbank.c
View file

@ -235,7 +235,8 @@ static void calxeda_init(MachineState *machine, enum cxmachines machine_id)
if (machine->firmware != NULL) {
sysboot_filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, machine->firmware);
if (sysboot_filename != NULL) {
if (load_image_targphys(sysboot_filename, 0xfff88000, 0x8000) < 0) {
if (load_image_targphys(sysboot_filename, 0xfff88000, 0x8000,
NULL) < 0) {
error_report("Unable to load %s", machine->firmware);
exit(1);
}

2
hw/arm/raspi.c
View file

@ -230,7 +230,7 @@ static void setup_boot(MachineState *machine, ARMCPU *cpu,
? FIRMWARE_ADDR_2 : FIRMWARE_ADDR_3;
/* load the firmware image (typically kernel.img) */
r = load_image_targphys(machine->firmware, firmware_addr,
ram_size - firmware_addr);
ram_size - firmware_addr, NULL);
if (r < 0) {
error_report("Failed to load firmware from %s", machine->firmware);
exit(1);

2
hw/arm/vexpress.c
View file

@ -578,7 +578,7 @@ static void vexpress_common_init(MachineState *machine)
exit(1);
}
image_size = load_image_targphys(fn, map[VE_NORFLASH0],
VEXPRESS_FLASH_SIZE);
VEXPRESS_FLASH_SIZE, NULL);
g_free(fn);
if (image_size < 0) {
error_report("Could not load ROM image '%s'", machine->firmware);

3
hw/core/generic-loader.c
View file

@ -148,7 +148,8 @@ static void generic_loader_realize(DeviceState *dev, Error **errp)
if (size < 0 || s->force_raw) {
/* Default to the maximum size being the machine's ram size */
size = load_image_targphys_as(s->file, s->addr, current_machine->ram_size, as);
size = load_image_targphys_as(s->file, s->addr,
current_machine->ram_size, as, NULL);
} else {
s->addr = entry;
}

2
hw/core/guest-loader.c
View file

@ -101,7 +101,7 @@ static void guest_loader_realize(DeviceState *dev, Error **errp)
/* Default to the maximum size being the machine's ram size */
size = load_image_targphys_as(file, s->addr, current_machine->ram_size,
NULL);
NULL, NULL);
if (size < 0) {
error_setg(errp, "Cannot load specified image %s", file);
return;

16
hw/core/loader.c
View file

@ -48,6 +48,7 @@
#include "qapi/error.h"
#include "qapi/qapi-commands-machine.h"
#include "qapi/type-helpers.h"
#include "qemu/units.h"
#include "trace.h"
#include "hw/hw.h"
#include "disas/disas.h"
@ -70,11 +71,11 @@
static int roms_loaded;
/* return the size or -1 if error */
int64_t get_image_size(const char *filename)
int64_t get_image_size(const char *filename, Error **errp)
{
int fd;
int64_t size;
fd = qemu_open(filename, O_RDONLY | O_BINARY, NULL);
fd = qemu_open(filename, O_RDONLY | O_BINARY, errp);
if (fd < 0)
return -1;
size = lseek(fd, 0, SEEK_END);
@ -118,18 +119,19 @@ ssize_t read_targphys(const char *name,
}
ssize_t load_image_targphys(const char *filename,
hwaddr addr, uint64_t max_sz)
hwaddr addr, uint64_t max_sz, Error **errp)
{
return load_image_targphys_as(filename, addr, max_sz, NULL);
return load_image_targphys_as(filename, addr, max_sz, NULL, errp);
}
/* return the size or -1 if error */
ssize_t load_image_targphys_as(const char *filename,
hwaddr addr, uint64_t max_sz, AddressSpace *as)
hwaddr addr, uint64_t max_sz, AddressSpace *as,
Error **errp)
{
ssize_t size;
size = get_image_size(filename);
size = get_image_size(filename, errp);
if (size < 0 || size > max_sz) {
return -1;
}
@ -150,7 +152,7 @@ ssize_t load_image_mr(const char *filename, MemoryRegion *mr)
return -1;
}
size = get_image_size(filename);
size = get_image_size(filename, NULL);
if (size < 0 || size > memory_region_size(mr)) {
return -1;

5
hw/hppa/machine.c
View file

@ -495,7 +495,7 @@ static void machine_HP_common_init_tail(MachineState *machine, PCIBus *pci_bus,
ram_addr_t initrd_base;
int64_t initrd_size;
initrd_size = get_image_size(initrd_filename);
initrd_size = get_image_size(initrd_filename, NULL);
if (initrd_size < 0) {
error_report("could not load initial ram disk '%s'",
initrd_filename);
@ -516,7 +516,8 @@ static void machine_HP_common_init_tail(MachineState *machine, PCIBus *pci_bus,
exit(1);
}
load_image_targphys(initrd_filename, initrd_base, initrd_size);
load_image_targphys(initrd_filename, initrd_base, initrd_size,
NULL);
cpu[0]->env.initrd_base = initrd_base;
cpu[0]->env.initrd_end = initrd_base + initrd_size;
}

2
hw/i386/multiboot.c
View file

@ -337,7 +337,7 @@ int load_multiboot(X86MachineState *x86ms,
*next_space = '\0';
}
mb_debug("multiboot loading module: %s", one_file);
mb_mod_length = get_image_size(one_file);
mb_mod_length = get_image_size(one_file, NULL);
if (mb_mod_length < 0) {
error_report("Failed to open file '%s'", one_file);
exit(1);

4
hw/i386/x86-common.c
View file

@ -924,7 +924,7 @@ void x86_load_linux(X86MachineState *x86ms,
exit(1);
}
dtb_size = get_image_size(dtb_filename);
dtb_size = get_image_size(dtb_filename, NULL);
if (dtb_size <= 0) {
fprintf(stderr, "qemu: error reading dtb %s: %s\n",
dtb_filename, strerror(errno));
@ -1025,7 +1025,7 @@ void x86_bios_rom_init(X86MachineState *x86ms, const char *default_firmware,
bios_name = MACHINE(x86ms)->firmware ?: default_firmware;
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
if (filename) {
bios_size = get_image_size(filename);
bios_size = get_image_size(filename, NULL);
} else {
bios_size = -1;
}

2
hw/ipmi/ipmi_bmc_sim.c
View file

@ -2211,7 +2211,7 @@ static void ipmi_fru_init(IPMIFru *fru)
goto out;
}
fsize = get_image_size(fru->filename);
fsize = get_image_size(fru->filename, NULL);
if (fsize > 0) {
size = QEMU_ALIGN_UP(fsize, fru->areasize);
fru->data = g_malloc0(size);

5
hw/loongarch/boot.c
View file

@ -328,14 +328,13 @@ static int64_t load_kernel_info(struct loongarch_boot_info *info)
}
if (info->initrd_filename) {
ssize_t initrd_size = get_image_size(info->initrd_filename);
ssize_t initrd_size = get_image_size(info->initrd_filename, NULL);
if (initrd_size > 0) {
initrd_offset = ROUND_UP(kernel_high + 4 * kernel_size, 64 * KiB);
initrd_offset = alloc_initrd_memory(info, initrd_offset,
initrd_size);
initrd_size = load_image_targphys(info->initrd_filename,
initrd_offset, initrd_size);
initrd_offset, initrd_size, NULL);
}
if (initrd_size == -1) {

2
hw/m68k/an5206.c
View file

@ -82,7 +82,7 @@ static void an5206_init(MachineState *machine)
}
if (kernel_size < 0) {
kernel_size = load_image_targphys(kernel_filename, KERNEL_LOAD_ADDR,
ram_size - KERNEL_LOAD_ADDR);
ram_size - KERNEL_LOAD_ADDR, NULL);
entry = KERNEL_LOAD_ADDR;
}
if (kernel_size < 0) {

4
hw/m68k/mcf5208.c
View file

@ -351,7 +351,7 @@ static void mcf5208evb_init(MachineState *machine)
error_report("Could not find ROM image '%s'", machine->firmware);
exit(1);
}
if (load_image_targphys(fn, 0x0, ROM_SIZE) < 8) {
if (load_image_targphys(fn, 0x0, ROM_SIZE, NULL) < 8) {
error_report("Could not load ROM image '%s'", machine->firmware);
exit(1);
}
@ -380,7 +380,7 @@ static void mcf5208evb_init(MachineState *machine)
}
if (kernel_size < 0) {
kernel_size = load_image_targphys(kernel_filename, 0x40000000,
ram_size);
ram_size, NULL);
entry = 0x40000000;
}
if (kernel_size < 0) {

2
hw/m68k/next-cube.c
View file

@ -1325,7 +1325,7 @@ static void next_cube_init(MachineState *machine)
memory_region_init_alias(&m->rom2, NULL, "next.rom2", &m->rom, 0x0,
0x20000);
memory_region_add_subregion(sysmem, 0x0, &m->rom2);
if (load_image_targphys(bios_name, 0x01000000, 0x20000) < 8) {
if (load_image_targphys(bios_name, 0x01000000, 0x20000, NULL) < 8) {
if (!qtest_enabled()) {
error_report("Failed to load firmware '%s'.", bios_name);
}

7
hw/m68k/q800.c
View file

@ -629,7 +629,7 @@ static void q800_machine_init(MachineState *machine)
/* load initrd */
if (initrd_filename) {
initrd_size = get_image_size(initrd_filename);
initrd_size = get_image_size(initrd_filename, NULL);
if (initrd_size < 0) {
error_report("could not load initial ram disk '%s'",
initrd_filename);
@ -638,7 +638,7 @@ static void q800_machine_init(MachineState *machine)
initrd_base = (ram_size - initrd_size) & TARGET_PAGE_MASK;
load_image_targphys(initrd_filename, initrd_base,
ram_size - initrd_base);
ram_size - initrd_base, NULL);
BOOTINFO2(param_ptr, BI_RAMDISK, initrd_base,
initrd_size);
} else {
@ -668,7 +668,8 @@ static void q800_machine_init(MachineState *machine)
/* Load MacROM binary */
if (filename) {
bios_size = load_image_targphys(filename, MACROM_ADDR, MACROM_SIZE);
bios_size = load_image_targphys(filename, MACROM_ADDR, MACROM_SIZE,
NULL);
g_free(filename);
} else {
bios_size = -1;

4
hw/m68k/virt.c
View file

@ -283,7 +283,7 @@ static void virt_init(MachineState *machine)
/* load initrd */
if (initrd_filename) {
initrd_size = get_image_size(initrd_filename);
initrd_size = get_image_size(initrd_filename, NULL);
if (initrd_size < 0) {
error_report("could not load initial ram disk '%s'",
initrd_filename);
@ -292,7 +292,7 @@ static void virt_init(MachineState *machine)
initrd_base = (ram_size - initrd_size) & TARGET_PAGE_MASK;
load_image_targphys(initrd_filename, initrd_base,
ram_size - initrd_base);
ram_size - initrd_base, NULL);
BOOTINFO2(param_ptr, BI_RAMDISK, initrd_base,
initrd_size);
} else {

5
hw/microblaze/boot.c
View file

@ -170,7 +170,7 @@ void microblaze_load_kernel(MicroBlazeCPU *cpu, bool is_little_endian,
/* Not an ELF image nor an u-boot image, try a RAW image. */
if (kernel_size < 0) {
kernel_size = load_image_targphys(kernel_filename, ddr_base,
ramsize);
ramsize, NULL);
boot_info.bootstrap_pc = ddr_base;
high = (ddr_base + kernel_size + 3) & ~3;
}
@ -189,7 +189,8 @@ void microblaze_load_kernel(MicroBlazeCPU *cpu, bool is_little_endian,
if (initrd_size < 0) {
initrd_size = load_image_targphys(initrd_filename,
boot_info.initrd_start,
ramsize - initrd_offset);
ramsize - initrd_offset,
NULL);
}
if (initrd_size < 0) {
error_report("could not load initrd '%s'",

2
hw/mips/boston.c
View file

@ -778,7 +778,7 @@ static void boston_mach_init(MachineState *machine)
if (machine->firmware) {
fw_size = load_image_targphys(machine->firmware,
0x1fc00000, 4 * MiB);
0x1fc00000, 4 * MiB, NULL);
if (fw_size == -1) {
error_report("unable to load firmware image '%s'",
machine->firmware);

9
hw/mips/fuloong2e.c
View file

@ -118,7 +118,7 @@ static uint64_t load_kernel(MIPSCPU *cpu)
initrd_size = 0;
initrd_offset = 0;
if (loaderparams.initrd_filename) {
initrd_size = get_image_size(loaderparams.initrd_filename);
initrd_size = get_image_size(loaderparams.initrd_filename, NULL);
if (initrd_size > 0) {
initrd_offset = ROUND_UP(kernel_high, INITRD_PAGE_SIZE);
if (initrd_offset + initrd_size > loaderparams.ram_size) {
@ -127,8 +127,9 @@ static uint64_t load_kernel(MIPSCPU *cpu)
exit(1);
}
initrd_size = load_image_targphys(loaderparams.initrd_filename,
initrd_offset,
loaderparams.ram_size - initrd_offset);
initrd_offset,
loaderparams.ram_size - initrd_offset,
NULL);
}
if (initrd_size == (target_ulong) -1) {
error_report("could not load initial ram disk '%s'",
@ -264,7 +265,7 @@ static void mips_fuloong2e_init(MachineState *machine)
machine->firmware ?: FULOONG_BIOSNAME);
if (filename) {
bios_size = load_image_targphys(filename, 0x1fc00000LL,
BIOS_SIZE);
BIOS_SIZE, NULL);
g_free(filename);
} else {
bios_size = -1;

2
hw/mips/jazz.c
View file

@ -245,7 +245,7 @@ static void mips_jazz_init(MachineState *machine,
machine->firmware ?: bios_name);
if (filename) {
bios_size = load_image_targphys(filename, 0xfff00000LL,
MAGNUM_BIOS_SIZE);
MAGNUM_BIOS_SIZE, NULL);
g_free(filename);
} else {
bios_size = -1;

10
hw/mips/loongson3_virt.c
View file

@ -371,7 +371,7 @@ static uint64_t load_kernel(CPUMIPSState *env)
initrd_size = 0;
initrd_offset = 0;
if (loaderparams.initrd_filename) {
initrd_size = get_image_size(loaderparams.initrd_filename);
initrd_size = get_image_size(loaderparams.initrd_filename, NULL);
if (initrd_size > 0) {
initrd_offset = MAX(loader_memmap[LOADER_INITRD].base,
ROUND_UP(kernel_high, INITRD_PAGE_SIZE));
@ -383,8 +383,9 @@ static uint64_t load_kernel(CPUMIPSState *env)
}
initrd_size = load_image_targphys(loaderparams.initrd_filename,
initrd_offset,
loaderparams.ram_size - initrd_offset);
initrd_offset,
loaderparams.ram_size - initrd_offset,
NULL);
}
if (initrd_size == (target_ulong) -1) {
@ -650,7 +651,8 @@ static void mips_loongson3_virt_init(MachineState *machine)
if (filename) {
bios_size = load_image_targphys(filename,
virt_memmap[VIRT_BIOS_ROM].base,
virt_memmap[VIRT_BIOS_ROM].size);
virt_memmap[VIRT_BIOS_ROM].size,
NULL);
g_free(filename);
} else {
bios_size = -1;

9
hw/mips/malta.c
View file

@ -892,7 +892,7 @@ static uint64_t load_kernel(void)
initrd_size = 0;
initrd_offset = 0;
if (loaderparams.initrd_filename) {
initrd_size = get_image_size(loaderparams.initrd_filename);
initrd_size = get_image_size(loaderparams.initrd_filename, NULL);
if (initrd_size > 0) {
/*
* The kernel allocates the bootmap memory in the low memory after
@ -908,8 +908,9 @@ static uint64_t load_kernel(void)
exit(1);
}
initrd_size = load_image_targphys(loaderparams.initrd_filename,
initrd_offset,
loaderparams.ram_size - initrd_offset);
initrd_offset,
loaderparams.ram_size - initrd_offset,
NULL);
}
if (initrd_size == (target_ulong) -1) {
error_report("could not load initial ram disk '%s'",
@ -1176,7 +1177,7 @@ void mips_malta_init(MachineState *machine)
machine->firmware ?: bios_name);
if (filename) {
bios_size = load_image_targphys(filename, FLASH_ADDRESS,
BIOS_SIZE);
BIOS_SIZE, NULL);
g_free(filename);
} else {
bios_size = -1;

2
hw/nubus/nubus-device.c
View file

@ -68,7 +68,7 @@ static void nubus_device_realize(DeviceState *dev, Error **errp)
path = g_strdup(nd->romfile);
}
size = get_image_size(path);
size = get_image_size(path, NULL);
if (size < 0) {
error_setg(errp, "failed to find romfile \"%s\"", nd->romfile);
g_free(path);

5
hw/openrisc/boot.c
View file

@ -44,7 +44,8 @@ hwaddr openrisc_load_kernel(ram_addr_t ram_size,
if (kernel_size < 0) {
kernel_size = load_image_targphys(kernel_filename,
KERNEL_LOAD_ADDR,
ram_size - KERNEL_LOAD_ADDR);
ram_size - KERNEL_LOAD_ADDR,
NULL);
high_addr = KERNEL_LOAD_ADDR + kernel_size;
}
@ -74,7 +75,7 @@ hwaddr openrisc_load_initrd(void *fdt, const char *filename,
size = load_ramdisk(filename, start, mem_size - start);
if (size < 0) {
size = load_image_targphys(filename, start, mem_size - start);
size = load_image_targphys(filename, start, mem_size - start, NULL);
if (size < 0) {
error_report("could not load ramdisk '%s'", filename);
exit(1);

2
hw/pci/pci.c
View file

@ -2557,7 +2557,7 @@ static void pci_add_option_rom(PCIDevice *pdev, bool is_default_rom,
path = g_strdup(pdev->romfile);
}
size = get_image_size(path);
size = get_image_size(path, NULL);
if (size < 0) {
error_setg(errp, "failed to find romfile \"%s\"", pdev->romfile);
return;

4
hw/ppc/amigaone.c
View file

@ -324,7 +324,7 @@ static void amigaone_init(MachineState *machine)
error_report("Could not find firmware '%s'", machine->firmware);
exit(1);
}
sz = load_image_targphys(filename, PROM_ADDR, PROM_SIZE);
sz = load_image_targphys(filename, PROM_ADDR, PROM_SIZE, NULL);
if (sz <= 0 || sz > PROM_SIZE) {
error_report("Could not load firmware '%s'", filename);
exit(1);
@ -413,7 +413,7 @@ static void amigaone_init(MachineState *machine)
loadaddr = ROUND_UP(loadaddr + 4 * MiB, 4 * KiB);
loadaddr = MAX(loadaddr, INITRD_MIN_ADDR);
sz = load_image_targphys(machine->initrd_filename, loadaddr,
bi->bd_info - loadaddr);
bi->bd_info - loadaddr, NULL);
if (sz <= 0) {
error_report("Could not load initrd '%s'",
machine->initrd_filename);

5
hw/ppc/e500.c
View file

@ -1227,7 +1227,7 @@ void ppce500_init(MachineState *machine)
kernel_base = cur_base;
kernel_size = load_image_targphys(machine->kernel_filename,
cur_base,
machine->ram_size - cur_base);
machine->ram_size - cur_base, NULL);
if (kernel_size < 0) {
error_report("could not load kernel '%s'",
machine->kernel_filename);
@ -1241,7 +1241,8 @@ void ppce500_init(MachineState *machine)
if (machine->initrd_filename) {
initrd_base = (cur_base + INITRD_LOAD_PAD) & ~INITRD_PAD_MASK;
initrd_size = load_image_targphys(machine->initrd_filename, initrd_base,
machine->ram_size - initrd_base);
machine->ram_size - initrd_base,
NULL);
if (initrd_size < 0) {
error_report("could not load initial ram disk '%s'",

9
hw/ppc/mac_newworld.c
View file

@ -188,7 +188,8 @@ static void ppc_core99_init(MachineState *machine)
if (bios_size <= 0) {
/* or load binary ROM image */
bios_size = load_image_targphys(filename, PROM_BASE, PROM_SIZE);
bios_size = load_image_targphys(filename, PROM_BASE, PROM_SIZE,
NULL);
}
g_free(filename);
}
@ -210,7 +211,8 @@ static void ppc_core99_init(MachineState *machine)
if (kernel_size < 0) {
kernel_size = load_image_targphys(machine->kernel_filename,
kernel_base,
machine->ram_size - kernel_base);
machine->ram_size - kernel_base,
NULL);
}
if (kernel_size < 0) {
error_report("could not load kernel '%s'",
@ -222,7 +224,8 @@ static void ppc_core99_init(MachineState *machine)
initrd_base = TARGET_PAGE_ALIGN(kernel_base + kernel_size + KERNEL_GAP);
initrd_size = load_image_targphys(machine->initrd_filename,
initrd_base,
machine->ram_size - initrd_base);
machine->ram_size - initrd_base,
NULL);
if (initrd_size < 0) {
error_report("could not load initial ram disk '%s'",
machine->initrd_filename);

9
hw/ppc/mac_oldworld.c
View file

@ -143,7 +143,8 @@ static void ppc_heathrow_init(MachineState *machine)
if (bios_size <= 0) {
/* or if could not load ELF try loading a binary ROM image */
bios_size = load_image_targphys(filename, PROM_BASE, PROM_SIZE);
bios_size = load_image_targphys(filename, PROM_BASE, PROM_SIZE,
NULL);
bios_addr = PROM_BASE;
}
g_free(filename);
@ -166,7 +167,8 @@ static void ppc_heathrow_init(MachineState *machine)
if (kernel_size < 0) {
kernel_size = load_image_targphys(machine->kernel_filename,
kernel_base,
machine->ram_size - kernel_base);
machine->ram_size - kernel_base,
NULL);
}
if (kernel_size < 0) {
error_report("could not load kernel '%s'",
@ -179,7 +181,8 @@ static void ppc_heathrow_init(MachineState *machine)
KERNEL_GAP);
initrd_size = load_image_targphys(machine->initrd_filename,
initrd_base,
machine->ram_size - initrd_base);
machine->ram_size - initrd_base,
NULL);
if (initrd_size < 0) {
error_report("could not load initial ram disk '%s'",
machine->initrd_filename);

5
hw/ppc/pegasos2.c
View file

@ -197,7 +197,8 @@ static void pegasos_init(MachineState *machine)
sz = load_elf(filename, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
ELFDATA2MSB, PPC_ELF_MACHINE, 0, 0);
if (sz <= 0) {
sz = load_image_targphys(filename, pm->vof ? 0 : prom_addr, PROM_SIZE);
sz = load_image_targphys(filename, pm->vof ? 0 : prom_addr, PROM_SIZE,
NULL);
}
if (sz <= 0 || sz > PROM_SIZE) {
error_report("Could not load firmware '%s'", filename);
@ -301,7 +302,7 @@ static void pegasos_init(MachineState *machine)
pm->initrd_addr = ROUND_UP(pm->initrd_addr, 4);
pm->initrd_addr = MAX(pm->initrd_addr, INITRD_MIN_ADDR);
sz = load_image_targphys(machine->initrd_filename, pm->initrd_addr,
machine->ram_size - pm->initrd_addr);
machine->ram_size - pm->initrd_addr, NULL);
if (sz <= 0) {
error_report("Could not load initrd '%s'",
machine->initrd_filename);

9
hw/ppc/pnv.c
View file

@ -1068,7 +1068,8 @@ static void pnv_init(MachineState *machine)
exit(1);
}
fw_size = load_image_targphys(fw_filename, pnv->fw_load_addr, FW_MAX_SIZE);
fw_size = load_image_targphys(fw_filename, pnv->fw_load_addr, FW_MAX_SIZE,
NULL);
if (fw_size < 0) {
error_report("Could not load OPAL firmware '%s'", fw_filename);
exit(1);
@ -1080,7 +1081,8 @@ static void pnv_init(MachineState *machine)
long kernel_size;
kernel_size = load_image_targphys(machine->kernel_filename,
KERNEL_LOAD_ADDR, KERNEL_MAX_SIZE);
KERNEL_LOAD_ADDR, KERNEL_MAX_SIZE,
NULL);
if (kernel_size < 0) {
error_report("Could not load kernel '%s'",
machine->kernel_filename);
@ -1092,7 +1094,8 @@ static void pnv_init(MachineState *machine)
if (machine->initrd_filename) {
pnv->initrd_base = INITRD_LOAD_ADDR;
pnv->initrd_size = load_image_targphys(machine->initrd_filename,
pnv->initrd_base, INITRD_MAX_SIZE);
pnv->initrd_base,
INITRD_MAX_SIZE, NULL);
if (pnv->initrd_size < 0) {
error_report("Could not load initial ram disk '%s'",
machine->initrd_filename);

3
hw/ppc/ppc440_bamboo.c
View file

@ -242,7 +242,8 @@ static void bamboo_init(MachineState *machine)
/* Load initrd. */
if (initrd_filename) {
initrd_size = load_image_targphys(initrd_filename, RAMDISK_ADDR,
machine->ram_size - RAMDISK_ADDR);
machine->ram_size - RAMDISK_ADDR,
NULL);
if (initrd_size < 0) {
error_report("could not load ram disk '%s' at %x",

8
hw/ppc/prep.c
View file

@ -280,7 +280,7 @@ static void ibm_40p_init(MachineState *machine)
bios_size = load_elf(filename, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
ELFDATA2MSB, PPC_ELF_MACHINE, 0, 0);
if (bios_size < 0) {
bios_size = load_image_targphys(filename, BIOS_ADDR, BIOS_SIZE);
bios_size = load_image_targphys(filename, BIOS_ADDR, BIOS_SIZE, NULL);
}
if (bios_size < 0 || bios_size > BIOS_SIZE) {
error_report("Could not load bios image '%s'", filename);
@ -379,7 +379,8 @@ static void ibm_40p_init(MachineState *machine)
kernel_base = KERNEL_LOAD_ADDR;
kernel_size = load_image_targphys(machine->kernel_filename,
kernel_base,
machine->ram_size - kernel_base);
machine->ram_size - kernel_base,
NULL);
if (kernel_size < 0) {
error_report("could not load kernel '%s'",
machine->kernel_filename);
@ -392,7 +393,8 @@ static void ibm_40p_init(MachineState *machine)
initrd_base = INITRD_LOAD_ADDR;
initrd_size = load_image_targphys(machine->initrd_filename,
initrd_base,
machine->ram_size - initrd_base);
machine->ram_size - initrd_base,
NULL);
if (initrd_size < 0) {
error_report("could not load initial ram disk '%s'",
machine->initrd_filename);

3
hw/ppc/sam460ex.c
View file

@ -494,7 +494,8 @@ static void sam460ex_init(MachineState *machine)
if (machine->initrd_filename) {
initrd_size = load_image_targphys(machine->initrd_filename,
RAMDISK_ADDR,
machine->ram_size - RAMDISK_ADDR);
machine->ram_size - RAMDISK_ADDR,
NULL);
if (initrd_size < 0) {
error_report("could not load ram disk '%s' at %x",
machine->initrd_filename, RAMDISK_ADDR);

8
hw/ppc/spapr.c
View file

@ -2854,7 +2854,7 @@ static void spapr_machine_init(MachineState *machine)
error_report("Could not find LPAR firmware '%s'", bios_name);
exit(1);
}
fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE);
fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE, NULL);
if (fw_size <= 0) {
error_report("Could not load LPAR firmware '%s'", filename);
exit(1);
@ -3115,9 +3115,9 @@ static void spapr_machine_init(MachineState *machine)
spapr->initrd_base = (spapr->kernel_addr + spapr->kernel_size
+ 0x1ffff) & ~0xffff;
spapr->initrd_size = load_image_targphys(initrd_filename,
spapr->initrd_base,
load_limit
- spapr->initrd_base);
spapr->initrd_base,
load_limit - spapr->initrd_base,
NULL);
if (spapr->initrd_size < 0) {
error_report("could not load initial ram disk '%s'",
initrd_filename);

5
hw/ppc/virtex_ml507.c
View file

@ -253,7 +253,7 @@ static void virtex_init(MachineState *machine)
/* If we failed loading ELF's try a raw image. */
kernel_size = load_image_targphys(kernel_filename,
boot_offset,
machine->ram_size);
machine->ram_size, NULL);
boot_info.bootstrap_pc = boot_offset;
high = boot_info.bootstrap_pc + kernel_size + 8192;
}
@ -264,7 +264,8 @@ static void virtex_init(MachineState *machine)
if (machine->initrd_filename) {
initrd_base = high = ROUND_UP(high, 4);
initrd_size = load_image_targphys(machine->initrd_filename,
high, machine->ram_size - high);
high, machine->ram_size - high,
NULL);
if (initrd_size < 0) {
error_report("couldn't load ram disk '%s'",

7
hw/riscv/boot.c
View file

@ -172,7 +172,8 @@ target_ulong riscv_load_firmware(const char *firmware_filename,
firmware_size = load_image_targphys_as(firmware_filename,
*firmware_load_addr,
current_machine->ram_size, NULL);
current_machine->ram_size, NULL,
NULL);
if (firmware_size > 0) {
return *firmware_load_addr + firmware_size;
@ -207,7 +208,7 @@ static void riscv_load_initrd(MachineState *machine, RISCVBootInfo *info)
size = load_ramdisk(filename, start, mem_size - start);
if (size == -1) {
size = load_image_targphys(filename, start, mem_size - start);
size = load_image_targphys(filename, start, mem_size - start, NULL);
if (size == -1) {
error_report("could not load ramdisk '%s'", filename);
exit(1);
@ -262,7 +263,7 @@ void riscv_load_kernel(MachineState *machine,
}
kernel_size = load_image_targphys_as(kernel_filename, kernel_start_addr,
current_machine->ram_size, NULL);
current_machine->ram_size, NULL, NULL);
if (kernel_size > 0) {
info->kernel_size = kernel_size;
info->image_low_addr = kernel_start_addr;

2
hw/rx/rx-gdbsim.c
View file

@ -63,7 +63,7 @@ static void rx_load_image(RXCPU *cpu, const char *filename,
long kernel_size;
int i;
kernel_size = load_image_targphys(filename, start, size);
kernel_size = load_image_targphys(filename, start, size, NULL);
if (kernel_size < 0) {
fprintf(stderr, "qemu: could not load kernel '%s'\n", filename);
exit(1);

8
hw/s390x/ipl.c
View file

@ -169,7 +169,7 @@ static void s390_ipl_realize(DeviceState *dev, Error **errp)
} else {
/* Try to load non-ELF file */
bios_size = load_image_targphys(bios_filename, ZIPL_IMAGE_START,
4096);
4096, NULL);
ipl->bios_start_addr = ZIPL_IMAGE_START;
}
g_free(bios_filename);
@ -188,7 +188,8 @@ static void s390_ipl_realize(DeviceState *dev, Error **errp)
&pentry, NULL,
NULL, NULL, ELFDATA2MSB, EM_S390, 0, 0);
if (kernel_size < 0) {
kernel_size = load_image_targphys(ipl->kernel, 0, ms->ram_size);
kernel_size = load_image_targphys(ipl->kernel, 0, ms->ram_size,
NULL);
if (kernel_size < 0) {
error_setg(errp, "could not load kernel '%s'", ipl->kernel);
return;
@ -247,7 +248,8 @@ static void s390_ipl_realize(DeviceState *dev, Error **errp)
initrd_offset += 0x100000;
}
initrd_size = load_image_targphys(ipl->initrd, initrd_offset,
ms->ram_size - initrd_offset);
ms->ram_size - initrd_offset,
NULL);
if (initrd_size == -1) {
error_setg(errp, "could not load initrd '%s'", ipl->initrd);
return;

8
hw/sh4/r2d.c
View file

@ -329,8 +329,9 @@ static void r2d_init(MachineState *machine)
int kernel_size;
kernel_size = load_image_targphys(kernel_filename,
SDRAM_BASE + LINUX_LOAD_OFFSET,
INITRD_LOAD_OFFSET - LINUX_LOAD_OFFSET);
SDRAM_BASE + LINUX_LOAD_OFFSET,
INITRD_LOAD_OFFSET - LINUX_LOAD_OFFSET,
NULL);
if (kernel_size < 0) {
error_report("qemu: could not load kernel '%s'", kernel_filename);
exit(1);
@ -350,7 +351,8 @@ static void r2d_init(MachineState *machine)
initrd_size = load_image_targphys(initrd_filename,
SDRAM_BASE + INITRD_LOAD_OFFSET,
SDRAM_SIZE - INITRD_LOAD_OFFSET);
SDRAM_SIZE - INITRD_LOAD_OFFSET,
NULL);
if (initrd_size < 0) {
error_report("qemu: could not load initrd '%s'", initrd_filename);

2
hw/smbios/smbios.c
View file

@ -1340,7 +1340,7 @@ void smbios_entry_add(QemuOpts *opts, Error **errp)
return;
}
size = get_image_size(val);
size = get_image_size(val, NULL);
if (size == -1 || size < sizeof(struct smbios_structure_header)) {
error_setg(errp, "Cannot read SMBIOS file %s", val);
return;

4
hw/sparc/leon3.c
View file

@ -349,7 +349,7 @@ static void leon3_generic_hw_init(MachineState *machine)
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
if (filename) {
bios_size = get_image_size(filename);
bios_size = get_image_size(filename, NULL);
} else {
bios_size = -1;
}
@ -360,7 +360,7 @@ static void leon3_generic_hw_init(MachineState *machine)
}
if (bios_size > 0) {
ret = load_image_targphys(filename, LEON3_PROM_OFFSET, bios_size);
ret = load_image_targphys(filename, LEON3_PROM_OFFSET, bios_size, NULL);
if (ret < 0 || ret > prom_size) {
error_report("could not load prom '%s'", filename);
exit(1);

8
hw/sparc/sun4m.c
View file

@ -245,7 +245,8 @@ static unsigned long sun4m_load_kernel(const char *kernel_filename,
if (kernel_size < 0)
kernel_size = load_image_targphys(kernel_filename,
KERNEL_LOAD_ADDR,
RAM_size - KERNEL_LOAD_ADDR);
RAM_size - KERNEL_LOAD_ADDR,
NULL);
if (kernel_size < 0) {
error_report("could not load kernel '%s'", kernel_filename);
exit(1);
@ -256,7 +257,8 @@ static unsigned long sun4m_load_kernel(const char *kernel_filename,
if (initrd_filename) {
*initrd_size = load_image_targphys(initrd_filename,
INITRD_LOAD_ADDR,
RAM_size - INITRD_LOAD_ADDR);
RAM_size - INITRD_LOAD_ADDR,
NULL);
if ((int)*initrd_size < 0) {
error_report("could not load initial ram disk '%s'",
initrd_filename);
@ -700,7 +702,7 @@ static void prom_init(hwaddr addr, const char *bios_name)
translate_prom_address, &addr, NULL,
NULL, NULL, NULL, ELFDATA2MSB, EM_SPARC, 0, 0);
if (ret < 0 || ret > PROM_SIZE_MAX) {
ret = load_image_targphys(filename, addr, PROM_SIZE_MAX);
ret = load_image_targphys(filename, addr, PROM_SIZE_MAX, NULL);
}
g_free(filename);
} else {

7
hw/sparc64/sun4u.c
View file

@ -182,7 +182,8 @@ static uint64_t sun4u_load_kernel(const char *kernel_filename,
if (kernel_size < 0) {
kernel_size = load_image_targphys(kernel_filename,
KERNEL_LOAD_ADDR,
RAM_size - KERNEL_LOAD_ADDR);
RAM_size - KERNEL_LOAD_ADDR,
NULL);
}
if (kernel_size < 0) {
error_report("could not load kernel '%s'", kernel_filename);
@ -195,7 +196,7 @@ static uint64_t sun4u_load_kernel(const char *kernel_filename,
*initrd_size = load_image_targphys(initrd_filename,
*initrd_addr,
RAM_size - *initrd_addr);
RAM_size - *initrd_addr, NULL);
if ((int)*initrd_size < 0) {
error_report("could not load initial ram disk '%s'",
initrd_filename);
@ -437,7 +438,7 @@ static void prom_init(hwaddr addr, const char *bios_name)
ret = load_elf(filename, NULL, translate_prom_address, &addr,
NULL, NULL, NULL, NULL, ELFDATA2MSB, EM_SPARCV9, 0, 0);
if (ret < 0 || ret > PROM_SIZE_MAX) {
ret = load_image_targphys(filename, addr, PROM_SIZE_MAX);
ret = load_image_targphys(filename, addr, PROM_SIZE_MAX, NULL);
}
g_free(filename);
} else {

3
hw/xtensa/xtfpga.c
View file

@ -381,7 +381,8 @@ static void xtfpga_init(const XtfpgaBoardDesc *board, MachineState *machine)
if (initrd_size < 0) {
initrd_size = load_image_targphys(initrd_filename,
cur_lowmem,
lowmem_end - cur_lowmem);
lowmem_end - cur_lowmem,
NULL);
}
if (initrd_size < 0) {
error_report("could not load initrd '%s'", initrd_filename);

8
include/hw/loader.h
View file

@ -1,6 +1,7 @@
#ifndef LOADER_H
#define LOADER_H
#include "hw/nvram/fw_cfg.h"
#include "qemu/typedefs.h"
/* loader.c */
/**
@ -10,7 +11,7 @@
* Returns the size of the image file on success, -1 otherwise.
* On error, errno is also set as appropriate.
*/
int64_t get_image_size(const char *filename);
int64_t get_image_size(const char *filename, Error **errp);
/**
* load_image_size: load an image file into specified buffer
* @filename: Path to the image file
@ -41,7 +42,8 @@ ssize_t load_image_size(const char *filename, void *addr, size_t size);
* Returns the size of the loaded image on success, -1 otherwise.
*/
ssize_t load_image_targphys_as(const char *filename,
hwaddr addr, uint64_t max_sz, AddressSpace *as);
hwaddr addr, uint64_t max_sz, AddressSpace *as,
Error **errp);
/**load_targphys_hex_as:
* @filename: Path to the .hex file
@ -61,7 +63,7 @@ ssize_t load_targphys_hex_as(const char *filename, hwaddr *entry,
* an AddressSpace.
*/
ssize_t load_image_targphys(const char *filename, hwaddr,
uint64_t max_sz);
uint64_t max_sz, Error **errp);
/**
* load_image_mr: load an image into a memory region

2
system/device_tree.c
View file

@ -83,7 +83,7 @@ void *load_device_tree(const char *filename_path, int *sizep)
void *fdt = NULL;
*sizep = 0;
dt_size = get_image_size(filename_path);
dt_size = get_image_size(filename_path, NULL);
if (dt_size < 0) {
error_report("Unable to get size of device tree file '%s'",
filename_path);