2007-09-16 23:08:06 +02:00
|
|
|
/*
|
2006-04-28 01:15:07 +02:00
|
|
|
* ARM kernel loader.
|
|
|
|
*
|
2007-11-11 01:04:49 +01:00
|
|
|
* Copyright (c) 2006-2007 CodeSourcery.
|
2006-04-28 01:15:07 +02:00
|
|
|
* Written by Paul Brook
|
|
|
|
*
|
2011-06-26 04:21:35 +02:00
|
|
|
* This code is licensed under the GPL.
|
2006-04-28 01:15:07 +02:00
|
|
|
*/
|
|
|
|
|
2015-12-07 17:23:45 +01:00
|
|
|
#include "qemu/osdep.h"
|
hw/arm: Replace fprintf(stderr, "*\n" with error_report()
Replace a large number of the fprintf(stderr, "*\n" calls with
error_report(). The functions were renamed with these commands and then
compiler issues where manually fixed.
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
Some lines where then manually tweaked to pass checkpatch.
The 'qemu: ' prefix was manually removed from the hw/arm/boot.c file.
Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>
Cc: qemu-arm@nongnu.org
Conversions that aren't followed by exit() dropped, because they might
be inappropriate.
Also trim trailing punctuation from error messages.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-Id: <20180203084315.20497-3-armbru@redhat.com>
2018-02-03 09:43:03 +01:00
|
|
|
#include "qemu/error-report.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 09:01:28 +01:00
|
|
|
#include "qapi/error.h"
|
2016-11-17 02:30:21 +01:00
|
|
|
#include <libfdt.h>
|
2013-02-04 15:40:22 +01:00
|
|
|
#include "hw/hw.h"
|
2013-04-09 16:26:55 +02:00
|
|
|
#include "hw/arm/arm.h"
|
2015-09-08 18:38:43 +02:00
|
|
|
#include "hw/arm/linux-boot-if.h"
|
2015-11-10 14:37:33 +01:00
|
|
|
#include "sysemu/kvm.h"
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/sysemu.h"
|
2016-05-12 14:22:27 +02:00
|
|
|
#include "sysemu/numa.h"
|
2013-02-04 15:40:22 +01:00
|
|
|
#include "hw/boards.h"
|
|
|
|
#include "hw/loader.h"
|
2009-09-20 16:58:02 +02:00
|
|
|
#include "elf.h"
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/device_tree.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/config-file.h"
|
2018-02-01 12:18:46 +01:00
|
|
|
#include "qemu/option.h"
|
2013-11-28 10:13:41 +01:00
|
|
|
#include "exec/address-spaces.h"
|
2006-04-28 01:15:07 +02:00
|
|
|
|
2013-12-17 20:42:30 +01:00
|
|
|
/* Kernel boot protocol is specified in the kernel docs
|
|
|
|
* Documentation/arm/Booting and Documentation/arm64/booting.txt
|
|
|
|
* They have different preferred image load offsets from system RAM base.
|
|
|
|
*/
|
2006-04-28 01:15:07 +02:00
|
|
|
#define KERNEL_ARGS_ADDR 0x100
|
|
|
|
#define KERNEL_LOAD_ADDR 0x00010000
|
2013-12-17 20:42:30 +01:00
|
|
|
#define KERNEL64_LOAD_ADDR 0x00080000
|
2006-04-28 01:15:07 +02:00
|
|
|
|
2017-04-20 18:32:28 +02:00
|
|
|
#define ARM64_TEXT_OFFSET_OFFSET 8
|
|
|
|
#define ARM64_MAGIC_OFFSET 56
|
|
|
|
|
2018-05-10 19:10:56 +02:00
|
|
|
AddressSpace *arm_boot_address_space(ARMCPU *cpu,
|
|
|
|
const struct arm_boot_info *info)
|
2018-03-02 11:45:36 +01:00
|
|
|
{
|
|
|
|
/* Return the address space to use for bootloader reads and writes.
|
|
|
|
* We prefer the secure address space if the CPU has it and we're
|
|
|
|
* going to boot the guest into it.
|
|
|
|
*/
|
|
|
|
int asidx;
|
|
|
|
CPUState *cs = CPU(cpu);
|
|
|
|
|
|
|
|
if (arm_feature(&cpu->env, ARM_FEATURE_EL3) && info->secure_boot) {
|
|
|
|
asidx = ARMASIdx_S;
|
|
|
|
} else {
|
|
|
|
asidx = ARMASIdx_NS;
|
|
|
|
}
|
|
|
|
|
|
|
|
return cpu_get_address_space(cs, asidx);
|
|
|
|
}
|
|
|
|
|
2013-12-17 20:42:30 +01:00
|
|
|
typedef enum {
|
2015-11-03 14:49:41 +01:00
|
|
|
FIXUP_NONE = 0, /* do nothing */
|
|
|
|
FIXUP_TERMINATOR, /* end of insns */
|
|
|
|
FIXUP_BOARDID, /* overwrite with board ID number */
|
2015-11-03 14:49:41 +01:00
|
|
|
FIXUP_BOARD_SETUP, /* overwrite with board specific setup code address */
|
2015-11-03 14:49:41 +01:00
|
|
|
FIXUP_ARGPTR, /* overwrite with pointer to kernel args */
|
|
|
|
FIXUP_ENTRYPOINT, /* overwrite with kernel entry point */
|
|
|
|
FIXUP_GIC_CPU_IF, /* overwrite with GIC CPU interface address */
|
|
|
|
FIXUP_BOOTREG, /* overwrite with boot register address */
|
|
|
|
FIXUP_DSB, /* overwrite with correct DSB insn for cpu */
|
2013-12-17 20:42:30 +01:00
|
|
|
FIXUP_MAX,
|
|
|
|
} FixupType;
|
|
|
|
|
|
|
|
typedef struct ARMInsnFixup {
|
|
|
|
uint32_t insn;
|
|
|
|
FixupType fixup;
|
|
|
|
} ARMInsnFixup;
|
|
|
|
|
2013-12-17 20:42:30 +01:00
|
|
|
static const ARMInsnFixup bootloader_aarch64[] = {
|
|
|
|
{ 0x580000c0 }, /* ldr x0, arg ; Load the lower 32-bits of DTB */
|
|
|
|
{ 0xaa1f03e1 }, /* mov x1, xzr */
|
|
|
|
{ 0xaa1f03e2 }, /* mov x2, xzr */
|
|
|
|
{ 0xaa1f03e3 }, /* mov x3, xzr */
|
|
|
|
{ 0x58000084 }, /* ldr x4, entry ; Load the lower 32-bits of kernel entry */
|
|
|
|
{ 0xd61f0080 }, /* br x4 ; Jump to the kernel entry point */
|
|
|
|
{ 0, FIXUP_ARGPTR }, /* arg: .word @DTB Lower 32-bits */
|
|
|
|
{ 0 }, /* .word @DTB Higher 32-bits */
|
|
|
|
{ 0, FIXUP_ENTRYPOINT }, /* entry: .word @Kernel Entry Lower 32-bits */
|
|
|
|
{ 0 }, /* .word @Kernel Entry Higher 32-bits */
|
|
|
|
{ 0, FIXUP_TERMINATOR }
|
|
|
|
};
|
|
|
|
|
2015-11-03 14:49:41 +01:00
|
|
|
/* A very small bootloader: call the board-setup code (if needed),
|
|
|
|
* set r0-r2, then jump to the kernel.
|
|
|
|
* If we're not calling boot setup code then we don't copy across
|
|
|
|
* the first BOOTLOADER_NO_BOARD_SETUP_OFFSET insns in this array.
|
|
|
|
*/
|
|
|
|
|
2013-12-17 20:42:30 +01:00
|
|
|
static const ARMInsnFixup bootloader[] = {
|
2016-04-20 23:35:28 +02:00
|
|
|
{ 0xe28fe004 }, /* add lr, pc, #4 */
|
2015-11-03 14:49:41 +01:00
|
|
|
{ 0xe51ff004 }, /* ldr pc, [pc, #-4] */
|
|
|
|
{ 0, FIXUP_BOARD_SETUP },
|
|
|
|
#define BOOTLOADER_NO_BOARD_SETUP_OFFSET 3
|
2013-12-17 20:42:30 +01:00
|
|
|
{ 0xe3a00000 }, /* mov r0, #0 */
|
|
|
|
{ 0xe59f1004 }, /* ldr r1, [pc, #4] */
|
|
|
|
{ 0xe59f2004 }, /* ldr r2, [pc, #4] */
|
|
|
|
{ 0xe59ff004 }, /* ldr pc, [pc, #4] */
|
|
|
|
{ 0, FIXUP_BOARDID },
|
|
|
|
{ 0, FIXUP_ARGPTR },
|
|
|
|
{ 0, FIXUP_ENTRYPOINT },
|
|
|
|
{ 0, FIXUP_TERMINATOR }
|
2006-04-28 01:15:07 +02:00
|
|
|
};
|
|
|
|
|
2012-01-26 12:43:48 +01:00
|
|
|
/* Handling for secondary CPU boot in a multicore system.
|
|
|
|
* Unlike the uniprocessor/primary CPU boot, this is platform
|
|
|
|
* dependent. The default code here is based on the secondary
|
|
|
|
* CPU boot protocol used on realview/vexpress boards, with
|
|
|
|
* some parameterisation to increase its flexibility.
|
|
|
|
* QEMU platform models for which this code is not appropriate
|
|
|
|
* should override write_secondary_boot and secondary_cpu_reset_hook
|
|
|
|
* instead.
|
|
|
|
*
|
|
|
|
* This code enables the interrupt controllers for the secondary
|
|
|
|
* CPUs and then puts all the secondary CPUs into a loop waiting
|
|
|
|
* for an interprocessor interrupt and polling a configurable
|
|
|
|
* location for the kernel secondary CPU entry point.
|
|
|
|
*/
|
2012-12-11 12:30:37 +01:00
|
|
|
#define DSB_INSN 0xf57ff04f
|
|
|
|
#define CP15_DSB_INSN 0xee070f9a /* mcr cp15, 0, r0, c7, c10, 4 */
|
|
|
|
|
2013-12-17 20:42:30 +01:00
|
|
|
static const ARMInsnFixup smpboot[] = {
|
|
|
|
{ 0xe59f2028 }, /* ldr r2, gic_cpu_if */
|
|
|
|
{ 0xe59f0028 }, /* ldr r0, bootreg_addr */
|
|
|
|
{ 0xe3a01001 }, /* mov r1, #1 */
|
|
|
|
{ 0xe5821000 }, /* str r1, [r2] - set GICC_CTLR.Enable */
|
|
|
|
{ 0xe3a010ff }, /* mov r1, #0xff */
|
|
|
|
{ 0xe5821004 }, /* str r1, [r2, 4] - set GIC_PMR.Priority to 0xff */
|
|
|
|
{ 0, FIXUP_DSB }, /* dsb */
|
|
|
|
{ 0xe320f003 }, /* wfi */
|
|
|
|
{ 0xe5901000 }, /* ldr r1, [r0] */
|
|
|
|
{ 0xe1110001 }, /* tst r1, r1 */
|
|
|
|
{ 0x0afffffb }, /* beq <wfi> */
|
|
|
|
{ 0xe12fff11 }, /* bx r1 */
|
|
|
|
{ 0, FIXUP_GIC_CPU_IF }, /* gic_cpu_if: .word 0x.... */
|
|
|
|
{ 0, FIXUP_BOOTREG }, /* bootreg_addr: .word 0x.... */
|
|
|
|
{ 0, FIXUP_TERMINATOR }
|
2007-11-11 01:04:49 +01:00
|
|
|
};
|
|
|
|
|
2013-12-17 20:42:30 +01:00
|
|
|
static void write_bootloader(const char *name, hwaddr addr,
|
2018-03-02 11:45:36 +01:00
|
|
|
const ARMInsnFixup *insns, uint32_t *fixupcontext,
|
|
|
|
AddressSpace *as)
|
2013-12-17 20:42:30 +01:00
|
|
|
{
|
|
|
|
/* Fix up the specified bootloader fragment and write it into
|
|
|
|
* guest memory using rom_add_blob_fixed(). fixupcontext is
|
|
|
|
* an array giving the values to write in for the fixup types
|
|
|
|
* which write a value into the code array.
|
|
|
|
*/
|
|
|
|
int i, len;
|
|
|
|
uint32_t *code;
|
|
|
|
|
|
|
|
len = 0;
|
|
|
|
while (insns[len].fixup != FIXUP_TERMINATOR) {
|
|
|
|
len++;
|
|
|
|
}
|
|
|
|
|
|
|
|
code = g_new0(uint32_t, len);
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
uint32_t insn = insns[i].insn;
|
|
|
|
FixupType fixup = insns[i].fixup;
|
|
|
|
|
|
|
|
switch (fixup) {
|
|
|
|
case FIXUP_NONE:
|
|
|
|
break;
|
|
|
|
case FIXUP_BOARDID:
|
2015-11-03 14:49:41 +01:00
|
|
|
case FIXUP_BOARD_SETUP:
|
2013-12-17 20:42:30 +01:00
|
|
|
case FIXUP_ARGPTR:
|
|
|
|
case FIXUP_ENTRYPOINT:
|
|
|
|
case FIXUP_GIC_CPU_IF:
|
|
|
|
case FIXUP_BOOTREG:
|
|
|
|
case FIXUP_DSB:
|
|
|
|
insn = fixupcontext[fixup];
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
code[i] = tswap32(insn);
|
|
|
|
}
|
|
|
|
|
2018-03-02 11:45:36 +01:00
|
|
|
rom_add_blob_fixed_as(name, code, len * sizeof(uint32_t), addr, as);
|
2013-12-17 20:42:30 +01:00
|
|
|
|
|
|
|
g_free(code);
|
|
|
|
}
|
|
|
|
|
2012-05-14 00:08:10 +02:00
|
|
|
static void default_write_secondary(ARMCPU *cpu,
|
2012-01-26 12:43:48 +01:00
|
|
|
const struct arm_boot_info *info)
|
|
|
|
{
|
2013-12-17 20:42:30 +01:00
|
|
|
uint32_t fixupcontext[FIXUP_MAX];
|
2018-03-02 11:45:36 +01:00
|
|
|
AddressSpace *as = arm_boot_address_space(cpu, info);
|
2013-12-17 20:42:30 +01:00
|
|
|
|
|
|
|
fixupcontext[FIXUP_GIC_CPU_IF] = info->gic_cpu_if_addr;
|
|
|
|
fixupcontext[FIXUP_BOOTREG] = info->smp_bootreg_addr;
|
|
|
|
if (arm_feature(&cpu->env, ARM_FEATURE_V7)) {
|
|
|
|
fixupcontext[FIXUP_DSB] = DSB_INSN;
|
|
|
|
} else {
|
|
|
|
fixupcontext[FIXUP_DSB] = CP15_DSB_INSN;
|
2012-01-26 12:43:48 +01:00
|
|
|
}
|
2013-12-17 20:42:30 +01:00
|
|
|
|
|
|
|
write_bootloader("smpboot", info->smp_loader_start,
|
2018-03-02 11:45:36 +01:00
|
|
|
smpboot, fixupcontext, as);
|
2012-01-26 12:43:48 +01:00
|
|
|
}
|
|
|
|
|
2016-01-29 23:50:43 +01:00
|
|
|
void arm_write_secure_board_setup_dummy_smc(ARMCPU *cpu,
|
|
|
|
const struct arm_boot_info *info,
|
|
|
|
hwaddr mvbar_addr)
|
|
|
|
{
|
2018-03-02 11:45:36 +01:00
|
|
|
AddressSpace *as = arm_boot_address_space(cpu, info);
|
2016-01-29 23:50:43 +01:00
|
|
|
int n;
|
|
|
|
uint32_t mvbar_blob[] = {
|
|
|
|
/* mvbar_addr: secure monitor vectors
|
|
|
|
* Default unimplemented and unused vectors to spin. Makes it
|
|
|
|
* easier to debug (as opposed to the CPU running away).
|
|
|
|
*/
|
|
|
|
0xeafffffe, /* (spin) */
|
|
|
|
0xeafffffe, /* (spin) */
|
|
|
|
0xe1b0f00e, /* movs pc, lr ;SMC exception return */
|
|
|
|
0xeafffffe, /* (spin) */
|
|
|
|
0xeafffffe, /* (spin) */
|
|
|
|
0xeafffffe, /* (spin) */
|
|
|
|
0xeafffffe, /* (spin) */
|
|
|
|
0xeafffffe, /* (spin) */
|
|
|
|
};
|
|
|
|
uint32_t board_setup_blob[] = {
|
|
|
|
/* board setup addr */
|
|
|
|
0xe3a00e00 + (mvbar_addr >> 4), /* mov r0, #mvbar_addr */
|
|
|
|
0xee0c0f30, /* mcr p15, 0, r0, c12, c0, 1 ;set MVBAR */
|
|
|
|
0xee110f11, /* mrc p15, 0, r0, c1 , c1, 0 ;read SCR */
|
|
|
|
0xe3800031, /* orr r0, #0x31 ;enable AW, FW, NS */
|
|
|
|
0xee010f11, /* mcr p15, 0, r0, c1, c1, 0 ;write SCR */
|
|
|
|
0xe1a0100e, /* mov r1, lr ;save LR across SMC */
|
|
|
|
0xe1600070, /* smc #0 ;call monitor to flush SCR */
|
|
|
|
0xe1a0f001, /* mov pc, r1 ;return */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* check that mvbar_addr is correctly aligned and relocatable (using MOV) */
|
|
|
|
assert((mvbar_addr & 0x1f) == 0 && (mvbar_addr >> 4) < 0x100);
|
|
|
|
|
|
|
|
/* check that these blobs don't overlap */
|
|
|
|
assert((mvbar_addr + sizeof(mvbar_blob) <= info->board_setup_addr)
|
|
|
|
|| (info->board_setup_addr + sizeof(board_setup_blob) <= mvbar_addr));
|
|
|
|
|
|
|
|
for (n = 0; n < ARRAY_SIZE(mvbar_blob); n++) {
|
|
|
|
mvbar_blob[n] = tswap32(mvbar_blob[n]);
|
|
|
|
}
|
2018-03-02 11:45:36 +01:00
|
|
|
rom_add_blob_fixed_as("board-setup-mvbar", mvbar_blob, sizeof(mvbar_blob),
|
|
|
|
mvbar_addr, as);
|
2016-01-29 23:50:43 +01:00
|
|
|
|
|
|
|
for (n = 0; n < ARRAY_SIZE(board_setup_blob); n++) {
|
|
|
|
board_setup_blob[n] = tswap32(board_setup_blob[n]);
|
|
|
|
}
|
2018-03-02 11:45:36 +01:00
|
|
|
rom_add_blob_fixed_as("board-setup", board_setup_blob,
|
|
|
|
sizeof(board_setup_blob), info->board_setup_addr, as);
|
2016-01-29 23:50:43 +01:00
|
|
|
}
|
|
|
|
|
2012-05-14 01:05:40 +02:00
|
|
|
static void default_reset_secondary(ARMCPU *cpu,
|
2012-01-26 12:43:48 +01:00
|
|
|
const struct arm_boot_info *info)
|
|
|
|
{
|
2018-03-02 11:45:36 +01:00
|
|
|
AddressSpace *as = arm_boot_address_space(cpu, info);
|
2015-06-24 05:19:22 +02:00
|
|
|
CPUState *cs = CPU(cpu);
|
2012-05-14 01:05:40 +02:00
|
|
|
|
2018-03-02 11:45:36 +01:00
|
|
|
address_space_stl_notdirty(as, info->smp_bootreg_addr,
|
Switch non-CPU callers from ld/st*_phys to address_space_ld/st*
Switch all the uses of ld/st*_phys to address_space_ld/st*,
except for those cases where the address space is the CPU's
(ie cs->as). This was done with the following script which
generates a Coccinelle patch.
A few over-80-columns lines in the result were rewrapped by
hand where Coccinelle failed to do the wrapping automatically,
as well as one location where it didn't put a line-continuation
'\' when wrapping lines on a change made to a match inside
a macro definition.
===begin===
#!/bin/sh -e
# Usage:
# ./ldst-phys.spatch.sh > ldst-phys.spatch
# spatch -sp_file ldst-phys.spatch -dir . | sed -e '/^+/s/\t/ /g' > out.patch
# patch -p1 < out.patch
for FN in ub uw_le uw_be l_le l_be q_le q_be uw l q; do
cat <<EOF
@ cpu_matches_ld_${FN} @
expression E1,E2;
identifier as;
@@
ld${FN}_phys(E1->as,E2)
@ other_matches_ld_${FN} depends on !cpu_matches_ld_${FN} @
expression E1,E2;
@@
-ld${FN}_phys(E1,E2)
+address_space_ld${FN}(E1,E2, MEMTXATTRS_UNSPECIFIED, NULL)
EOF
done
for FN in b w_le w_be l_le l_be q_le q_be w l q; do
cat <<EOF
@ cpu_matches_st_${FN} @
expression E1,E2,E3;
identifier as;
@@
st${FN}_phys(E1->as,E2,E3)
@ other_matches_st_${FN} depends on !cpu_matches_st_${FN} @
expression E1,E2,E3;
@@
-st${FN}_phys(E1,E2,E3)
+address_space_st${FN}(E1,E2,E3, MEMTXATTRS_UNSPECIFIED, NULL)
EOF
done
===endit===
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com>
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
2015-04-26 17:49:24 +02:00
|
|
|
0, MEMTXATTRS_UNSPECIFIED, NULL);
|
2015-06-24 05:19:22 +02:00
|
|
|
cpu_set_pc(cs, info->smp_loader_start);
|
2012-01-26 12:43:48 +01:00
|
|
|
}
|
|
|
|
|
2014-01-31 15:47:32 +01:00
|
|
|
static inline bool have_dtb(const struct arm_boot_info *info)
|
|
|
|
{
|
|
|
|
return info->dtb_filename || info->get_dtb;
|
|
|
|
}
|
|
|
|
|
2009-04-09 19:19:47 +02:00
|
|
|
#define WRITE_WORD(p, value) do { \
|
2018-03-02 11:45:36 +01:00
|
|
|
address_space_stl_notdirty(as, p, value, \
|
Switch non-CPU callers from ld/st*_phys to address_space_ld/st*
Switch all the uses of ld/st*_phys to address_space_ld/st*,
except for those cases where the address space is the CPU's
(ie cs->as). This was done with the following script which
generates a Coccinelle patch.
A few over-80-columns lines in the result were rewrapped by
hand where Coccinelle failed to do the wrapping automatically,
as well as one location where it didn't put a line-continuation
'\' when wrapping lines on a change made to a match inside
a macro definition.
===begin===
#!/bin/sh -e
# Usage:
# ./ldst-phys.spatch.sh > ldst-phys.spatch
# spatch -sp_file ldst-phys.spatch -dir . | sed -e '/^+/s/\t/ /g' > out.patch
# patch -p1 < out.patch
for FN in ub uw_le uw_be l_le l_be q_le q_be uw l q; do
cat <<EOF
@ cpu_matches_ld_${FN} @
expression E1,E2;
identifier as;
@@
ld${FN}_phys(E1->as,E2)
@ other_matches_ld_${FN} depends on !cpu_matches_ld_${FN} @
expression E1,E2;
@@
-ld${FN}_phys(E1,E2)
+address_space_ld${FN}(E1,E2, MEMTXATTRS_UNSPECIFIED, NULL)
EOF
done
for FN in b w_le w_be l_le l_be q_le q_be w l q; do
cat <<EOF
@ cpu_matches_st_${FN} @
expression E1,E2,E3;
identifier as;
@@
st${FN}_phys(E1->as,E2,E3)
@ other_matches_st_${FN} depends on !cpu_matches_st_${FN} @
expression E1,E2,E3;
@@
-st${FN}_phys(E1,E2,E3)
+address_space_st${FN}(E1,E2,E3, MEMTXATTRS_UNSPECIFIED, NULL)
EOF
done
===endit===
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com>
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
2015-04-26 17:49:24 +02:00
|
|
|
MEMTXATTRS_UNSPECIFIED, NULL); \
|
2009-04-09 19:19:47 +02:00
|
|
|
p += 4; \
|
|
|
|
} while (0)
|
|
|
|
|
2018-03-02 11:45:36 +01:00
|
|
|
static void set_kernel_args(const struct arm_boot_info *info, AddressSpace *as)
|
2006-04-28 01:15:07 +02:00
|
|
|
{
|
2012-01-29 08:52:15 +01:00
|
|
|
int initrd_size = info->initrd_size;
|
2012-10-23 12:30:10 +02:00
|
|
|
hwaddr base = info->loader_start;
|
|
|
|
hwaddr p;
|
2006-04-28 01:15:07 +02:00
|
|
|
|
2009-04-09 19:19:47 +02:00
|
|
|
p = base + KERNEL_ARGS_ADDR;
|
2006-04-28 01:15:07 +02:00
|
|
|
/* ATAG_CORE */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 5);
|
|
|
|
WRITE_WORD(p, 0x54410001);
|
|
|
|
WRITE_WORD(p, 1);
|
|
|
|
WRITE_WORD(p, 0x1000);
|
|
|
|
WRITE_WORD(p, 0);
|
2006-04-28 01:15:07 +02:00
|
|
|
/* ATAG_MEM */
|
2008-04-14 22:27:51 +02:00
|
|
|
/* TODO: handle multiple chips on one ATAG list */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 4);
|
|
|
|
WRITE_WORD(p, 0x54410002);
|
|
|
|
WRITE_WORD(p, info->ram_size);
|
|
|
|
WRITE_WORD(p, info->loader_start);
|
2006-04-28 01:15:07 +02:00
|
|
|
if (initrd_size) {
|
|
|
|
/* ATAG_INITRD2 */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 4);
|
|
|
|
WRITE_WORD(p, 0x54420005);
|
2012-10-26 17:29:38 +02:00
|
|
|
WRITE_WORD(p, info->initrd_start);
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, initrd_size);
|
2006-04-28 01:15:07 +02:00
|
|
|
}
|
2008-04-14 22:27:51 +02:00
|
|
|
if (info->kernel_cmdline && *info->kernel_cmdline) {
|
2006-04-28 01:15:07 +02:00
|
|
|
/* ATAG_CMDLINE */
|
|
|
|
int cmdline_size;
|
|
|
|
|
2008-04-14 22:27:51 +02:00
|
|
|
cmdline_size = strlen(info->kernel_cmdline);
|
2018-03-02 11:45:36 +01:00
|
|
|
address_space_write(as, p + 8, MEMTXATTRS_UNSPECIFIED,
|
|
|
|
(const uint8_t *)info->kernel_cmdline,
|
|
|
|
cmdline_size + 1);
|
2006-04-28 01:15:07 +02:00
|
|
|
cmdline_size = (cmdline_size >> 2) + 1;
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, cmdline_size + 2);
|
|
|
|
WRITE_WORD(p, 0x54410009);
|
|
|
|
p += cmdline_size * 4;
|
2006-04-28 01:15:07 +02:00
|
|
|
}
|
2008-04-14 22:27:51 +02:00
|
|
|
if (info->atag_board) {
|
|
|
|
/* ATAG_BOARD */
|
|
|
|
int atag_board_len;
|
2009-04-09 19:19:47 +02:00
|
|
|
uint8_t atag_board_buf[0x1000];
|
2008-04-14 22:27:51 +02:00
|
|
|
|
2009-04-09 19:19:47 +02:00
|
|
|
atag_board_len = (info->atag_board(info, atag_board_buf) + 3) & ~3;
|
|
|
|
WRITE_WORD(p, (atag_board_len + 8) >> 2);
|
|
|
|
WRITE_WORD(p, 0x414f4d50);
|
2018-03-02 11:45:36 +01:00
|
|
|
address_space_write(as, p, MEMTXATTRS_UNSPECIFIED,
|
|
|
|
atag_board_buf, atag_board_len);
|
2008-04-14 22:27:51 +02:00
|
|
|
p += atag_board_len;
|
|
|
|
}
|
2006-04-28 01:15:07 +02:00
|
|
|
/* ATAG_END */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
|
|
|
WRITE_WORD(p, 0);
|
2006-04-28 01:15:07 +02:00
|
|
|
}
|
|
|
|
|
2018-03-02 11:45:36 +01:00
|
|
|
static void set_kernel_args_old(const struct arm_boot_info *info,
|
|
|
|
AddressSpace *as)
|
2007-07-28 00:08:46 +02:00
|
|
|
{
|
2012-10-23 12:30:10 +02:00
|
|
|
hwaddr p;
|
2009-04-09 19:19:47 +02:00
|
|
|
const char *s;
|
2012-01-29 08:52:15 +01:00
|
|
|
int initrd_size = info->initrd_size;
|
2012-10-23 12:30:10 +02:00
|
|
|
hwaddr base = info->loader_start;
|
2007-07-28 00:08:46 +02:00
|
|
|
|
|
|
|
/* see linux/include/asm-arm/setup.h */
|
2009-04-09 19:19:47 +02:00
|
|
|
p = base + KERNEL_ARGS_ADDR;
|
2007-07-28 00:08:46 +02:00
|
|
|
/* page_size */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 4096);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* nr_pages */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, info->ram_size / 4096);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* ramdisk_size */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
2007-07-28 00:08:46 +02:00
|
|
|
#define FLAG_READONLY 1
|
|
|
|
#define FLAG_RDLOAD 4
|
|
|
|
#define FLAG_RDPROMPT 8
|
|
|
|
/* flags */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, FLAG_READONLY | FLAG_RDLOAD | FLAG_RDPROMPT);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* rootdev */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, (31 << 8) | 0); /* /dev/mtdblock0 */
|
2007-07-28 00:08:46 +02:00
|
|
|
/* video_num_cols */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* video_num_rows */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* video_x */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* video_y */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* memc_control_reg */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* unsigned char sounddefault */
|
|
|
|
/* unsigned char adfsdrives */
|
|
|
|
/* unsigned char bytes_per_char_h */
|
|
|
|
/* unsigned char bytes_per_char_v */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* pages_in_bank[4] */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
|
|
|
WRITE_WORD(p, 0);
|
|
|
|
WRITE_WORD(p, 0);
|
|
|
|
WRITE_WORD(p, 0);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* pages_in_vram */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* initrd_start */
|
2012-10-26 17:29:38 +02:00
|
|
|
if (initrd_size) {
|
|
|
|
WRITE_WORD(p, info->initrd_start);
|
|
|
|
} else {
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
2012-10-26 17:29:38 +02:00
|
|
|
}
|
2007-07-28 00:08:46 +02:00
|
|
|
/* initrd_size */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, initrd_size);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* rd_start */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* system_rev */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* system_serial_low */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* system_serial_high */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* mem_fclk_21285 */
|
2009-04-09 19:19:47 +02:00
|
|
|
WRITE_WORD(p, 0);
|
2007-07-28 00:08:46 +02:00
|
|
|
/* zero unused fields */
|
2009-04-09 19:19:47 +02:00
|
|
|
while (p < base + KERNEL_ARGS_ADDR + 256 + 1024) {
|
|
|
|
WRITE_WORD(p, 0);
|
|
|
|
}
|
|
|
|
s = info->kernel_cmdline;
|
|
|
|
if (s) {
|
2018-03-02 11:45:36 +01:00
|
|
|
address_space_write(as, p, MEMTXATTRS_UNSPECIFIED,
|
|
|
|
(const uint8_t *)s, strlen(s) + 1);
|
2009-04-09 19:19:47 +02:00
|
|
|
} else {
|
|
|
|
WRITE_WORD(p, 0);
|
|
|
|
}
|
2007-07-28 00:08:46 +02:00
|
|
|
}
|
|
|
|
|
2018-02-09 11:40:30 +01:00
|
|
|
static void fdt_add_psci_node(void *fdt)
|
|
|
|
{
|
|
|
|
uint32_t cpu_suspend_fn;
|
|
|
|
uint32_t cpu_off_fn;
|
|
|
|
uint32_t cpu_on_fn;
|
|
|
|
uint32_t migrate_fn;
|
|
|
|
ARMCPU *armcpu = ARM_CPU(qemu_get_cpu(0));
|
|
|
|
const char *psci_method;
|
|
|
|
int64_t psci_conduit;
|
2018-04-10 14:02:24 +02:00
|
|
|
int rc;
|
2018-02-09 11:40:30 +01:00
|
|
|
|
|
|
|
psci_conduit = object_property_get_int(OBJECT(armcpu),
|
|
|
|
"psci-conduit",
|
|
|
|
&error_abort);
|
|
|
|
switch (psci_conduit) {
|
|
|
|
case QEMU_PSCI_CONDUIT_DISABLED:
|
|
|
|
return;
|
|
|
|
case QEMU_PSCI_CONDUIT_HVC:
|
|
|
|
psci_method = "hvc";
|
|
|
|
break;
|
|
|
|
case QEMU_PSCI_CONDUIT_SMC:
|
|
|
|
psci_method = "smc";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
2018-04-10 14:02:24 +02:00
|
|
|
/*
|
|
|
|
* If /psci node is present in provided DTB, assume that no fixup
|
|
|
|
* is necessary and all PSCI configuration should be taken as-is
|
|
|
|
*/
|
|
|
|
rc = fdt_path_offset(fdt, "/psci");
|
|
|
|
if (rc >= 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-02-09 11:40:30 +01:00
|
|
|
qemu_fdt_add_subnode(fdt, "/psci");
|
|
|
|
if (armcpu->psci_version == 2) {
|
|
|
|
const char comp[] = "arm,psci-0.2\0arm,psci";
|
|
|
|
qemu_fdt_setprop(fdt, "/psci", "compatible", comp, sizeof(comp));
|
|
|
|
|
|
|
|
cpu_off_fn = QEMU_PSCI_0_2_FN_CPU_OFF;
|
|
|
|
if (arm_feature(&armcpu->env, ARM_FEATURE_AARCH64)) {
|
|
|
|
cpu_suspend_fn = QEMU_PSCI_0_2_FN64_CPU_SUSPEND;
|
|
|
|
cpu_on_fn = QEMU_PSCI_0_2_FN64_CPU_ON;
|
|
|
|
migrate_fn = QEMU_PSCI_0_2_FN64_MIGRATE;
|
|
|
|
} else {
|
|
|
|
cpu_suspend_fn = QEMU_PSCI_0_2_FN_CPU_SUSPEND;
|
|
|
|
cpu_on_fn = QEMU_PSCI_0_2_FN_CPU_ON;
|
|
|
|
migrate_fn = QEMU_PSCI_0_2_FN_MIGRATE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
qemu_fdt_setprop_string(fdt, "/psci", "compatible", "arm,psci");
|
|
|
|
|
|
|
|
cpu_suspend_fn = QEMU_PSCI_0_1_FN_CPU_SUSPEND;
|
|
|
|
cpu_off_fn = QEMU_PSCI_0_1_FN_CPU_OFF;
|
|
|
|
cpu_on_fn = QEMU_PSCI_0_1_FN_CPU_ON;
|
|
|
|
migrate_fn = QEMU_PSCI_0_1_FN_MIGRATE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We adopt the PSCI spec's nomenclature, and use 'conduit' to refer
|
|
|
|
* to the instruction that should be used to invoke PSCI functions.
|
|
|
|
* However, the device tree binding uses 'method' instead, so that is
|
|
|
|
* what we should use here.
|
|
|
|
*/
|
|
|
|
qemu_fdt_setprop_string(fdt, "/psci", "method", psci_method);
|
|
|
|
|
|
|
|
qemu_fdt_setprop_cell(fdt, "/psci", "cpu_suspend", cpu_suspend_fn);
|
|
|
|
qemu_fdt_setprop_cell(fdt, "/psci", "cpu_off", cpu_off_fn);
|
|
|
|
qemu_fdt_setprop_cell(fdt, "/psci", "cpu_on", cpu_on_fn);
|
|
|
|
qemu_fdt_setprop_cell(fdt, "/psci", "migrate", migrate_fn);
|
|
|
|
}
|
|
|
|
|
2018-05-10 19:10:56 +02:00
|
|
|
int arm_load_dtb(hwaddr addr, const struct arm_boot_info *binfo,
|
|
|
|
hwaddr addr_limit, AddressSpace *as)
|
2012-03-02 12:56:38 +01:00
|
|
|
{
|
|
|
|
void *fdt = NULL;
|
2018-06-29 16:11:01 +02:00
|
|
|
int size, rc, n = 0;
|
2013-07-16 14:25:06 +02:00
|
|
|
uint32_t acells, scells;
|
2016-05-12 14:22:27 +02:00
|
|
|
char *nodename;
|
|
|
|
unsigned int i;
|
|
|
|
hwaddr mem_base, mem_len;
|
2018-06-29 16:11:01 +02:00
|
|
|
char **node_path;
|
|
|
|
Error *err = NULL;
|
2012-03-02 12:56:38 +01:00
|
|
|
|
2013-11-22 18:17:10 +01:00
|
|
|
if (binfo->dtb_filename) {
|
|
|
|
char *filename;
|
|
|
|
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, binfo->dtb_filename);
|
|
|
|
if (!filename) {
|
|
|
|
fprintf(stderr, "Couldn't open dtb file %s\n", binfo->dtb_filename);
|
|
|
|
goto fail;
|
|
|
|
}
|
2012-03-02 12:56:38 +01:00
|
|
|
|
2013-11-22 18:17:10 +01:00
|
|
|
fdt = load_device_tree(filename, &size);
|
|
|
|
if (!fdt) {
|
|
|
|
fprintf(stderr, "Couldn't open dtb file %s\n", filename);
|
|
|
|
g_free(filename);
|
|
|
|
goto fail;
|
|
|
|
}
|
2012-03-02 12:56:38 +01:00
|
|
|
g_free(filename);
|
2014-12-11 13:07:53 +01:00
|
|
|
} else {
|
2013-11-22 18:17:10 +01:00
|
|
|
fdt = binfo->get_dtb(binfo, &size);
|
|
|
|
if (!fdt) {
|
|
|
|
fprintf(stderr, "Board was unable to create a dtb blob\n");
|
|
|
|
goto fail;
|
|
|
|
}
|
2012-03-02 12:56:38 +01:00
|
|
|
}
|
|
|
|
|
2014-09-12 15:06:50 +02:00
|
|
|
if (addr_limit > addr && size > (addr_limit - addr)) {
|
|
|
|
/* Installing the device tree blob at addr would exceed addr_limit.
|
|
|
|
* Whether this constitutes failure is up to the caller to decide,
|
|
|
|
* so just return 0 as size, i.e., no error.
|
|
|
|
*/
|
|
|
|
g_free(fdt);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-02-19 17:42:30 +01:00
|
|
|
acells = qemu_fdt_getprop_cell(fdt, "/", "#address-cells",
|
|
|
|
NULL, &error_fatal);
|
|
|
|
scells = qemu_fdt_getprop_cell(fdt, "/", "#size-cells",
|
|
|
|
NULL, &error_fatal);
|
2012-07-20 14:34:50 +02:00
|
|
|
if (acells == 0 || scells == 0) {
|
|
|
|
fprintf(stderr, "dtb file invalid (#address-cells or #size-cells 0)\n");
|
2013-06-25 19:34:13 +02:00
|
|
|
goto fail;
|
2012-07-20 14:34:50 +02:00
|
|
|
}
|
|
|
|
|
2013-07-16 14:25:06 +02:00
|
|
|
if (scells < 2 && binfo->ram_size >= (1ULL << 32)) {
|
|
|
|
/* This is user error so deserves a friendlier error message
|
|
|
|
* than the failure of setprop_sized_cells would provide
|
|
|
|
*/
|
2012-07-20 14:34:50 +02:00
|
|
|
fprintf(stderr, "qemu: dtb file not compatible with "
|
|
|
|
"RAM size > 4GB\n");
|
2013-06-25 19:34:13 +02:00
|
|
|
goto fail;
|
2012-07-20 14:34:50 +02:00
|
|
|
}
|
|
|
|
|
2018-06-29 16:11:01 +02:00
|
|
|
/* nop all root nodes matching /memory or /memory@unit-address */
|
|
|
|
node_path = qemu_fdt_node_unit_path(fdt, "memory", &err);
|
|
|
|
if (err) {
|
|
|
|
error_report_err(err);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
while (node_path[n]) {
|
|
|
|
if (g_str_has_prefix(node_path[n], "/memory")) {
|
|
|
|
qemu_fdt_nop_node(fdt, node_path[n]);
|
|
|
|
}
|
|
|
|
n++;
|
|
|
|
}
|
|
|
|
g_strfreev(node_path);
|
|
|
|
|
2016-05-12 14:22:27 +02:00
|
|
|
if (nb_numa_nodes > 0) {
|
|
|
|
mem_base = binfo->loader_start;
|
|
|
|
for (i = 0; i < nb_numa_nodes; i++) {
|
|
|
|
mem_len = numa_info[i].node_mem;
|
|
|
|
nodename = g_strdup_printf("/memory@%" PRIx64, mem_base);
|
|
|
|
qemu_fdt_add_subnode(fdt, nodename);
|
|
|
|
qemu_fdt_setprop_string(fdt, nodename, "device_type", "memory");
|
|
|
|
rc = qemu_fdt_setprop_sized_cells(fdt, nodename, "reg",
|
|
|
|
acells, mem_base,
|
|
|
|
scells, mem_len);
|
|
|
|
if (rc < 0) {
|
|
|
|
fprintf(stderr, "couldn't set %s/reg for node %d\n", nodename,
|
|
|
|
i);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
qemu_fdt_setprop_cell(fdt, nodename, "numa-node-id", i);
|
|
|
|
mem_base += mem_len;
|
|
|
|
g_free(nodename);
|
|
|
|
}
|
|
|
|
} else {
|
2018-06-29 16:11:01 +02:00
|
|
|
nodename = g_strdup_printf("/memory@%" PRIx64, binfo->loader_start);
|
|
|
|
qemu_fdt_add_subnode(fdt, nodename);
|
|
|
|
qemu_fdt_setprop_string(fdt, nodename, "device_type", "memory");
|
2016-11-17 02:30:21 +01:00
|
|
|
|
2018-06-29 16:11:01 +02:00
|
|
|
rc = qemu_fdt_setprop_sized_cells(fdt, nodename, "reg",
|
2016-05-12 14:22:27 +02:00
|
|
|
acells, binfo->loader_start,
|
|
|
|
scells, binfo->ram_size);
|
|
|
|
if (rc < 0) {
|
2018-06-29 16:11:01 +02:00
|
|
|
fprintf(stderr, "couldn't set %s reg\n", nodename);
|
2016-05-12 14:22:27 +02:00
|
|
|
goto fail;
|
|
|
|
}
|
2018-06-29 16:11:01 +02:00
|
|
|
g_free(nodename);
|
2012-03-02 12:56:38 +01:00
|
|
|
}
|
|
|
|
|
2016-11-17 02:30:21 +01:00
|
|
|
rc = fdt_path_offset(fdt, "/chosen");
|
|
|
|
if (rc < 0) {
|
|
|
|
qemu_fdt_add_subnode(fdt, "/chosen");
|
|
|
|
}
|
|
|
|
|
2012-06-17 17:35:36 +02:00
|
|
|
if (binfo->kernel_cmdline && *binfo->kernel_cmdline) {
|
2013-11-11 09:14:41 +01:00
|
|
|
rc = qemu_fdt_setprop_string(fdt, "/chosen", "bootargs",
|
|
|
|
binfo->kernel_cmdline);
|
2012-06-17 17:35:36 +02:00
|
|
|
if (rc < 0) {
|
|
|
|
fprintf(stderr, "couldn't set /chosen/bootargs\n");
|
2013-06-25 19:34:13 +02:00
|
|
|
goto fail;
|
2012-06-17 17:35:36 +02:00
|
|
|
}
|
2012-03-02 12:56:38 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (binfo->initrd_size) {
|
2013-11-11 09:14:41 +01:00
|
|
|
rc = qemu_fdt_setprop_cell(fdt, "/chosen", "linux,initrd-start",
|
|
|
|
binfo->initrd_start);
|
2012-03-02 12:56:38 +01:00
|
|
|
if (rc < 0) {
|
|
|
|
fprintf(stderr, "couldn't set /chosen/linux,initrd-start\n");
|
2013-06-25 19:34:13 +02:00
|
|
|
goto fail;
|
2012-03-02 12:56:38 +01:00
|
|
|
}
|
|
|
|
|
2013-11-11 09:14:41 +01:00
|
|
|
rc = qemu_fdt_setprop_cell(fdt, "/chosen", "linux,initrd-end",
|
|
|
|
binfo->initrd_start + binfo->initrd_size);
|
2012-03-02 12:56:38 +01:00
|
|
|
if (rc < 0) {
|
|
|
|
fprintf(stderr, "couldn't set /chosen/linux,initrd-end\n");
|
2013-06-25 19:34:13 +02:00
|
|
|
goto fail;
|
2012-03-02 12:56:38 +01:00
|
|
|
}
|
|
|
|
}
|
2013-07-16 14:25:10 +02:00
|
|
|
|
2018-02-09 11:40:30 +01:00
|
|
|
fdt_add_psci_node(fdt);
|
|
|
|
|
2013-07-16 14:25:10 +02:00
|
|
|
if (binfo->modify_dtb) {
|
|
|
|
binfo->modify_dtb(binfo, fdt);
|
|
|
|
}
|
|
|
|
|
2013-11-11 09:14:41 +01:00
|
|
|
qemu_fdt_dumpdtb(fdt, size);
|
2012-03-02 12:56:38 +01:00
|
|
|
|
2014-09-12 15:06:50 +02:00
|
|
|
/* Put the DTB into the memory map as a ROM image: this will ensure
|
|
|
|
* the DTB is copied again upon reset, even if addr points into RAM.
|
|
|
|
*/
|
2018-03-02 11:45:36 +01:00
|
|
|
rom_add_blob_fixed_as("dtb", fdt, size, addr, as);
|
2012-03-02 12:56:38 +01:00
|
|
|
|
2013-06-25 19:34:13 +02:00
|
|
|
g_free(fdt);
|
|
|
|
|
2014-09-12 15:06:50 +02:00
|
|
|
return size;
|
2013-06-25 19:34:13 +02:00
|
|
|
|
|
|
|
fail:
|
|
|
|
g_free(fdt);
|
|
|
|
return -1;
|
2012-03-02 12:56:38 +01:00
|
|
|
}
|
|
|
|
|
2011-03-05 13:51:45 +01:00
|
|
|
static void do_cpu_reset(void *opaque)
|
2009-11-11 19:07:53 +01:00
|
|
|
{
|
2012-05-05 12:40:39 +02:00
|
|
|
ARMCPU *cpu = opaque;
|
2015-06-24 05:19:22 +02:00
|
|
|
CPUState *cs = CPU(cpu);
|
2012-05-05 12:40:39 +02:00
|
|
|
CPUARMState *env = &cpu->env;
|
2011-06-23 17:53:48 +02:00
|
|
|
const struct arm_boot_info *info = env->boot_info;
|
2009-11-11 19:07:53 +01:00
|
|
|
|
2015-06-24 05:19:22 +02:00
|
|
|
cpu_reset(cs);
|
2009-11-11 19:07:53 +01:00
|
|
|
if (info) {
|
|
|
|
if (!info->is_linux) {
|
2016-03-04 12:30:21 +01:00
|
|
|
int i;
|
2009-11-11 19:07:53 +01:00
|
|
|
/* Jump to the entry point. */
|
2015-06-24 05:19:22 +02:00
|
|
|
uint64_t entry = info->entry;
|
|
|
|
|
2016-03-04 12:30:21 +01:00
|
|
|
switch (info->endianness) {
|
|
|
|
case ARM_ENDIANNESS_LE:
|
|
|
|
env->cp15.sctlr_el[1] &= ~SCTLR_E0E;
|
|
|
|
for (i = 1; i < 4; ++i) {
|
|
|
|
env->cp15.sctlr_el[i] &= ~SCTLR_EE;
|
|
|
|
}
|
|
|
|
env->uncached_cpsr &= ~CPSR_E;
|
|
|
|
break;
|
|
|
|
case ARM_ENDIANNESS_BE8:
|
|
|
|
env->cp15.sctlr_el[1] |= SCTLR_E0E;
|
|
|
|
for (i = 1; i < 4; ++i) {
|
|
|
|
env->cp15.sctlr_el[i] |= SCTLR_EE;
|
|
|
|
}
|
|
|
|
env->uncached_cpsr |= CPSR_E;
|
|
|
|
break;
|
|
|
|
case ARM_ENDIANNESS_BE32:
|
|
|
|
env->cp15.sctlr_el[1] |= SCTLR_B;
|
|
|
|
break;
|
|
|
|
case ARM_ENDIANNESS_UNKNOWN:
|
|
|
|
break; /* Board's decision */
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
2015-06-24 05:19:22 +02:00
|
|
|
if (!env->aarch64) {
|
2014-08-04 15:41:53 +02:00
|
|
|
env->thumb = info->entry & 1;
|
2015-06-24 05:19:22 +02:00
|
|
|
entry &= 0xfffffffe;
|
2014-08-04 15:41:53 +02:00
|
|
|
}
|
2015-06-24 05:19:22 +02:00
|
|
|
cpu_set_pc(cs, entry);
|
2009-11-11 19:07:53 +01:00
|
|
|
} else {
|
2014-12-16 00:09:47 +01:00
|
|
|
/* If we are booting Linux then we need to check whether we are
|
|
|
|
* booting into secure or non-secure state and adjust the state
|
|
|
|
* accordingly. Out of reset, ARM is defined to be in secure state
|
|
|
|
* (SCR.NS = 0), we change that here if non-secure boot has been
|
|
|
|
* requested.
|
|
|
|
*/
|
2015-02-05 14:37:22 +01:00
|
|
|
if (arm_feature(env, ARM_FEATURE_EL3)) {
|
|
|
|
/* AArch64 is defined to come out of reset into EL3 if enabled.
|
|
|
|
* If we are booting Linux then we need to adjust our EL as
|
|
|
|
* Linux expects us to be in EL2 or EL1. AArch32 resets into
|
|
|
|
* SVC, which Linux expects, so no privilege/exception level to
|
|
|
|
* adjust.
|
|
|
|
*/
|
|
|
|
if (env->aarch64) {
|
2016-02-03 14:46:33 +01:00
|
|
|
env->cp15.scr_el3 |= SCR_RW;
|
2015-02-05 14:37:22 +01:00
|
|
|
if (arm_feature(env, ARM_FEATURE_EL2)) {
|
2016-02-03 14:46:33 +01:00
|
|
|
env->cp15.hcr_el2 |= HCR_RW;
|
2015-02-05 14:37:22 +01:00
|
|
|
env->pstate = PSTATE_MODE_EL2h;
|
|
|
|
} else {
|
|
|
|
env->pstate = PSTATE_MODE_EL1h;
|
|
|
|
}
|
2018-03-13 16:34:51 +01:00
|
|
|
/* AArch64 kernels never boot in secure mode */
|
|
|
|
assert(!info->secure_boot);
|
|
|
|
/* This hook is only supported for AArch32 currently:
|
|
|
|
* bootloader_aarch64[] will not call the hook, and
|
|
|
|
* the code above has already dropped us into EL2 or EL1.
|
|
|
|
*/
|
|
|
|
assert(!info->secure_board_setup);
|
2015-02-05 14:37:22 +01:00
|
|
|
}
|
|
|
|
|
2018-03-13 16:34:52 +01:00
|
|
|
if (arm_feature(env, ARM_FEATURE_EL2)) {
|
|
|
|
/* If we have EL2 then Linux expects the HVC insn to work */
|
|
|
|
env->cp15.scr_el3 |= SCR_HCE;
|
|
|
|
}
|
|
|
|
|
2015-02-05 14:37:22 +01:00
|
|
|
/* Set to non-secure if not a secure boot */
|
2015-11-10 14:37:33 +01:00
|
|
|
if (!info->secure_boot &&
|
|
|
|
(cs != first_cpu || !info->secure_board_setup)) {
|
2015-02-05 14:37:22 +01:00
|
|
|
/* Linux expects non-secure state */
|
|
|
|
env->cp15.scr_el3 |= SCR_NS;
|
|
|
|
}
|
2014-12-16 00:09:47 +01:00
|
|
|
}
|
|
|
|
|
2015-06-24 05:19:22 +02:00
|
|
|
if (cs == first_cpu) {
|
2018-03-02 11:45:36 +01:00
|
|
|
AddressSpace *as = arm_boot_address_space(cpu, info);
|
|
|
|
|
2015-06-24 05:19:22 +02:00
|
|
|
cpu_set_pc(cs, info->loader_start);
|
2013-12-17 20:42:30 +01:00
|
|
|
|
2014-01-31 15:47:32 +01:00
|
|
|
if (!have_dtb(info)) {
|
2012-03-02 12:56:38 +01:00
|
|
|
if (old_param) {
|
2018-03-02 11:45:36 +01:00
|
|
|
set_kernel_args_old(info, as);
|
2012-03-02 12:56:38 +01:00
|
|
|
} else {
|
2018-03-02 11:45:36 +01:00
|
|
|
set_kernel_args(info, as);
|
2012-03-02 12:56:38 +01:00
|
|
|
}
|
2011-03-05 13:51:45 +01:00
|
|
|
}
|
2009-11-11 19:07:53 +01:00
|
|
|
} else {
|
2012-05-14 01:05:40 +02:00
|
|
|
info->secondary_cpu_reset_hook(cpu, info);
|
2009-11-11 19:07:53 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
hw/arm: pass pristine kernel image to guest firmware over fw_cfg
Introduce the new boolean field "arm_boot_info.firmware_loaded". When this
field is set, it means that the portion of guest DRAM that the VCPU
normally starts to execute, or the pflash chip that the VCPU normally
starts to execute, has been populated by board-specific code with
full-fledged guest firmware code, before the board calls
arm_load_kernel().
Simultaneously, "arm_boot_info.firmware_loaded" guarantees that the board
code has set up the global firmware config instance, for arm_load_kernel()
to find with fw_cfg_find().
Guest kernel (-kernel) and guest firmware (-bios, -pflash) has always been
possible to specify independently on the command line. The following cases
should be considered:
nr -bios -pflash -kernel description
unit#0
-- ------- ------- ------- -------------------------------------------
1 present present absent Board code rejects this case, -bios and
present present present -pflash unit#0 are exclusive. Left intact
by this patch.
2 absent absent present Traditional kernel loading, with qemu's
minimal board firmware. Left intact by this
patch.
3 absent present absent Preexistent case for booting guest firmware
present absent absent loaded with -bios or -pflash. Left intact
by this patch.
4 absent absent absent Preexistent case for not loading any
firmware or kernel up-front. Left intact by
this patch.
5 present absent present New case introduced by this patch: kernel
absent present present image is passed to externally loaded
firmware in unmodified form, using fw_cfg.
An easy way to see that this patch doesn't interfere with existing cases
is to realize that "info->firmware_loaded" is constant zero at this point.
Which makes the "outer" condition unchanged, and the "inner" condition
(with the fw_cfg-related code) dead.
Signed-off-by: Laszlo Ersek <lersek@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 1419250305-31062-11-git-send-email-pbonzini@redhat.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2014-12-22 13:11:44 +01:00
|
|
|
/**
|
|
|
|
* load_image_to_fw_cfg() - Load an image file into an fw_cfg entry identified
|
|
|
|
* by key.
|
|
|
|
* @fw_cfg: The firmware config instance to store the data in.
|
|
|
|
* @size_key: The firmware config key to store the size of the loaded
|
|
|
|
* data under, with fw_cfg_add_i32().
|
|
|
|
* @data_key: The firmware config key to store the loaded data under,
|
|
|
|
* with fw_cfg_add_bytes().
|
|
|
|
* @image_name: The name of the image file to load. If it is NULL, the
|
|
|
|
* function returns without doing anything.
|
|
|
|
* @try_decompress: Whether the image should be decompressed (gunzipped) before
|
|
|
|
* adding it to fw_cfg. If decompression fails, the image is
|
|
|
|
* loaded as-is.
|
|
|
|
*
|
|
|
|
* In case of failure, the function prints an error message to stderr and the
|
|
|
|
* process exits with status 1.
|
|
|
|
*/
|
|
|
|
static void load_image_to_fw_cfg(FWCfgState *fw_cfg, uint16_t size_key,
|
|
|
|
uint16_t data_key, const char *image_name,
|
|
|
|
bool try_decompress)
|
|
|
|
{
|
|
|
|
size_t size = -1;
|
|
|
|
uint8_t *data;
|
|
|
|
|
|
|
|
if (image_name == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (try_decompress) {
|
|
|
|
size = load_image_gzipped_buffer(image_name,
|
|
|
|
LOAD_IMAGE_MAX_GUNZIP_BYTES, &data);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (size == (size_t)-1) {
|
|
|
|
gchar *contents;
|
|
|
|
gsize length;
|
|
|
|
|
|
|
|
if (!g_file_get_contents(image_name, &contents, &length, NULL)) {
|
hw/arm: Replace fprintf(stderr, "*\n" with error_report()
Replace a large number of the fprintf(stderr, "*\n" calls with
error_report(). The functions were renamed with these commands and then
compiler issues where manually fixed.
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
Some lines where then manually tweaked to pass checkpatch.
The 'qemu: ' prefix was manually removed from the hw/arm/boot.c file.
Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>
Cc: qemu-arm@nongnu.org
Conversions that aren't followed by exit() dropped, because they might
be inappropriate.
Also trim trailing punctuation from error messages.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-Id: <20180203084315.20497-3-armbru@redhat.com>
2018-02-03 09:43:03 +01:00
|
|
|
error_report("failed to load \"%s\"", image_name);
|
hw/arm: pass pristine kernel image to guest firmware over fw_cfg
Introduce the new boolean field "arm_boot_info.firmware_loaded". When this
field is set, it means that the portion of guest DRAM that the VCPU
normally starts to execute, or the pflash chip that the VCPU normally
starts to execute, has been populated by board-specific code with
full-fledged guest firmware code, before the board calls
arm_load_kernel().
Simultaneously, "arm_boot_info.firmware_loaded" guarantees that the board
code has set up the global firmware config instance, for arm_load_kernel()
to find with fw_cfg_find().
Guest kernel (-kernel) and guest firmware (-bios, -pflash) has always been
possible to specify independently on the command line. The following cases
should be considered:
nr -bios -pflash -kernel description
unit#0
-- ------- ------- ------- -------------------------------------------
1 present present absent Board code rejects this case, -bios and
present present present -pflash unit#0 are exclusive. Left intact
by this patch.
2 absent absent present Traditional kernel loading, with qemu's
minimal board firmware. Left intact by this
patch.
3 absent present absent Preexistent case for booting guest firmware
present absent absent loaded with -bios or -pflash. Left intact
by this patch.
4 absent absent absent Preexistent case for not loading any
firmware or kernel up-front. Left intact by
this patch.
5 present absent present New case introduced by this patch: kernel
absent present present image is passed to externally loaded
firmware in unmodified form, using fw_cfg.
An easy way to see that this patch doesn't interfere with existing cases
is to realize that "info->firmware_loaded" is constant zero at this point.
Which makes the "outer" condition unchanged, and the "inner" condition
(with the fw_cfg-related code) dead.
Signed-off-by: Laszlo Ersek <lersek@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 1419250305-31062-11-git-send-email-pbonzini@redhat.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2014-12-22 13:11:44 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
size = length;
|
|
|
|
data = (uint8_t *)contents;
|
|
|
|
}
|
|
|
|
|
|
|
|
fw_cfg_add_i32(fw_cfg, size_key, size);
|
|
|
|
fw_cfg_add_bytes(fw_cfg, data_key, data, size);
|
|
|
|
}
|
|
|
|
|
2015-09-08 18:38:43 +02:00
|
|
|
static int do_arm_linux_init(Object *obj, void *opaque)
|
|
|
|
{
|
|
|
|
if (object_dynamic_cast(obj, TYPE_ARM_LINUX_BOOT_IF)) {
|
|
|
|
ARMLinuxBootIf *albif = ARM_LINUX_BOOT_IF(obj);
|
|
|
|
ARMLinuxBootIfClass *albifc = ARM_LINUX_BOOT_IF_GET_CLASS(obj);
|
|
|
|
struct arm_boot_info *info = opaque;
|
|
|
|
|
|
|
|
if (albifc->arm_linux_init) {
|
|
|
|
albifc->arm_linux_init(albif, info->secure_boot);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-08-14 18:17:21 +02:00
|
|
|
static int64_t arm_load_elf(struct arm_boot_info *info, uint64_t *pentry,
|
|
|
|
uint64_t *lowaddr, uint64_t *highaddr,
|
|
|
|
int elf_machine, AddressSpace *as)
|
2016-03-04 12:30:21 +01:00
|
|
|
{
|
|
|
|
bool elf_is64;
|
|
|
|
union {
|
|
|
|
Elf32_Ehdr h32;
|
|
|
|
Elf64_Ehdr h64;
|
|
|
|
} elf_header;
|
|
|
|
int data_swab = 0;
|
|
|
|
bool big_endian;
|
2018-08-14 18:17:21 +02:00
|
|
|
int64_t ret = -1;
|
2016-03-04 12:30:21 +01:00
|
|
|
Error *err = NULL;
|
|
|
|
|
|
|
|
|
|
|
|
load_elf_hdr(info->kernel_filename, &elf_header, &elf_is64, &err);
|
|
|
|
if (err) {
|
2018-03-09 18:09:44 +01:00
|
|
|
error_free(err);
|
2016-03-04 12:30:21 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (elf_is64) {
|
|
|
|
big_endian = elf_header.h64.e_ident[EI_DATA] == ELFDATA2MSB;
|
|
|
|
info->endianness = big_endian ? ARM_ENDIANNESS_BE8
|
|
|
|
: ARM_ENDIANNESS_LE;
|
|
|
|
} else {
|
|
|
|
big_endian = elf_header.h32.e_ident[EI_DATA] == ELFDATA2MSB;
|
|
|
|
if (big_endian) {
|
|
|
|
if (bswap32(elf_header.h32.e_flags) & EF_ARM_BE8) {
|
|
|
|
info->endianness = ARM_ENDIANNESS_BE8;
|
|
|
|
} else {
|
|
|
|
info->endianness = ARM_ENDIANNESS_BE32;
|
|
|
|
/* In BE32, the CPU has a different view of the per-byte
|
|
|
|
* address map than the rest of the system. BE32 ELF files
|
|
|
|
* are organised such that they can be programmed through
|
|
|
|
* the CPU's per-word byte-reversed view of the world. QEMU
|
|
|
|
* however loads ELF files independently of the CPU. So
|
|
|
|
* tell the ELF loader to byte reverse the data for us.
|
|
|
|
*/
|
|
|
|
data_swab = 2;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
info->endianness = ARM_ENDIANNESS_LE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-02 11:45:36 +01:00
|
|
|
ret = load_elf_as(info->kernel_filename, NULL, NULL,
|
|
|
|
pentry, lowaddr, highaddr, big_endian, elf_machine,
|
|
|
|
1, data_swab, as);
|
2016-03-04 12:30:21 +01:00
|
|
|
if (ret <= 0) {
|
|
|
|
/* The header loaded but the image didn't */
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-04-20 18:32:28 +02:00
|
|
|
static uint64_t load_aarch64_image(const char *filename, hwaddr mem_base,
|
2018-03-02 11:45:36 +01:00
|
|
|
hwaddr *entry, AddressSpace *as)
|
2017-04-20 18:32:28 +02:00
|
|
|
{
|
|
|
|
hwaddr kernel_load_offset = KERNEL64_LOAD_ADDR;
|
|
|
|
uint8_t *buffer;
|
|
|
|
int size;
|
|
|
|
|
|
|
|
/* On aarch64, it's the bootloader's job to uncompress the kernel. */
|
|
|
|
size = load_image_gzipped_buffer(filename, LOAD_IMAGE_MAX_GUNZIP_BYTES,
|
|
|
|
&buffer);
|
|
|
|
|
|
|
|
if (size < 0) {
|
|
|
|
gsize len;
|
|
|
|
|
|
|
|
/* Load as raw file otherwise */
|
|
|
|
if (!g_file_get_contents(filename, (char **)&buffer, &len, NULL)) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
size = len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check the arm64 magic header value -- very old kernels may not have it */
|
2018-03-09 18:09:44 +01:00
|
|
|
if (size > ARM64_MAGIC_OFFSET + 4 &&
|
|
|
|
memcmp(buffer + ARM64_MAGIC_OFFSET, "ARM\x64", 4) == 0) {
|
2017-04-20 18:32:28 +02:00
|
|
|
uint64_t hdrvals[2];
|
|
|
|
|
|
|
|
/* The arm64 Image header has text_offset and image_size fields at 8 and
|
|
|
|
* 16 bytes into the Image header, respectively. The text_offset field
|
|
|
|
* is only valid if the image_size is non-zero.
|
|
|
|
*/
|
|
|
|
memcpy(&hdrvals, buffer + ARM64_TEXT_OFFSET_OFFSET, sizeof(hdrvals));
|
|
|
|
if (hdrvals[1] != 0) {
|
|
|
|
kernel_load_offset = le64_to_cpu(hdrvals[0]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*entry = mem_base + kernel_load_offset;
|
2018-03-02 11:45:36 +01:00
|
|
|
rom_add_blob_fixed_as(filename, buffer, size, *entry, as);
|
2017-04-20 18:32:28 +02:00
|
|
|
|
|
|
|
g_free(buffer);
|
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2018-05-10 19:10:56 +02:00
|
|
|
void arm_load_kernel(ARMCPU *cpu, struct arm_boot_info *info)
|
2006-04-28 01:15:07 +02:00
|
|
|
{
|
2014-10-24 13:19:11 +02:00
|
|
|
CPUState *cs;
|
2006-04-28 01:15:07 +02:00
|
|
|
int kernel_size;
|
|
|
|
int initrd_size;
|
2007-03-07 00:52:01 +01:00
|
|
|
int is_linux = 0;
|
2014-09-12 15:06:50 +02:00
|
|
|
uint64_t elf_entry, elf_low_addr, elf_high_addr;
|
2014-03-21 19:44:36 +01:00
|
|
|
int elf_machine;
|
2017-04-20 18:32:28 +02:00
|
|
|
hwaddr entry;
|
2013-12-17 20:42:30 +01:00
|
|
|
static const ARMInsnFixup *primary_loader;
|
2018-03-02 11:45:36 +01:00
|
|
|
AddressSpace *as = arm_boot_address_space(cpu, info);
|
2006-04-28 01:15:07 +02:00
|
|
|
|
2018-05-31 15:50:51 +02:00
|
|
|
/* CPU objects (unlike devices) are not automatically reset on system
|
|
|
|
* reset, so we must always register a handler to do so. If we're
|
|
|
|
* actually loading a kernel, the handler is also responsible for
|
|
|
|
* arranging that we start it correctly.
|
|
|
|
*/
|
|
|
|
for (cs = first_cpu; cs; cs = CPU_NEXT(cs)) {
|
|
|
|
qemu_register_reset(do_cpu_reset, ARM_CPU(cs));
|
|
|
|
}
|
|
|
|
|
2015-11-10 14:37:33 +01:00
|
|
|
/* The board code is not supposed to set secure_board_setup unless
|
|
|
|
* running its code in secure mode is actually possible, and KVM
|
|
|
|
* doesn't support secure.
|
|
|
|
*/
|
|
|
|
assert(!(info->secure_board_setup && kvm_enabled()));
|
|
|
|
|
2016-10-17 20:22:17 +02:00
|
|
|
info->dtb_filename = qemu_opt_get(qemu_get_machine_opts(), "dtb");
|
2018-05-10 19:10:56 +02:00
|
|
|
info->dtb_limit = 0;
|
2016-10-17 20:22:17 +02:00
|
|
|
|
2006-04-28 01:15:07 +02:00
|
|
|
/* Load the kernel. */
|
hw/arm: pass pristine kernel image to guest firmware over fw_cfg
Introduce the new boolean field "arm_boot_info.firmware_loaded". When this
field is set, it means that the portion of guest DRAM that the VCPU
normally starts to execute, or the pflash chip that the VCPU normally
starts to execute, has been populated by board-specific code with
full-fledged guest firmware code, before the board calls
arm_load_kernel().
Simultaneously, "arm_boot_info.firmware_loaded" guarantees that the board
code has set up the global firmware config instance, for arm_load_kernel()
to find with fw_cfg_find().
Guest kernel (-kernel) and guest firmware (-bios, -pflash) has always been
possible to specify independently on the command line. The following cases
should be considered:
nr -bios -pflash -kernel description
unit#0
-- ------- ------- ------- -------------------------------------------
1 present present absent Board code rejects this case, -bios and
present present present -pflash unit#0 are exclusive. Left intact
by this patch.
2 absent absent present Traditional kernel loading, with qemu's
minimal board firmware. Left intact by this
patch.
3 absent present absent Preexistent case for booting guest firmware
present absent absent loaded with -bios or -pflash. Left intact
by this patch.
4 absent absent absent Preexistent case for not loading any
firmware or kernel up-front. Left intact by
this patch.
5 present absent present New case introduced by this patch: kernel
absent present present image is passed to externally loaded
firmware in unmodified form, using fw_cfg.
An easy way to see that this patch doesn't interfere with existing cases
is to realize that "info->firmware_loaded" is constant zero at this point.
Which makes the "outer" condition unchanged, and the "inner" condition
(with the fw_cfg-related code) dead.
Signed-off-by: Laszlo Ersek <lersek@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 1419250305-31062-11-git-send-email-pbonzini@redhat.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2014-12-22 13:11:44 +01:00
|
|
|
if (!info->kernel_filename || info->firmware_loaded) {
|
2014-09-12 15:06:50 +02:00
|
|
|
|
|
|
|
if (have_dtb(info)) {
|
hw/arm: pass pristine kernel image to guest firmware over fw_cfg
Introduce the new boolean field "arm_boot_info.firmware_loaded". When this
field is set, it means that the portion of guest DRAM that the VCPU
normally starts to execute, or the pflash chip that the VCPU normally
starts to execute, has been populated by board-specific code with
full-fledged guest firmware code, before the board calls
arm_load_kernel().
Simultaneously, "arm_boot_info.firmware_loaded" guarantees that the board
code has set up the global firmware config instance, for arm_load_kernel()
to find with fw_cfg_find().
Guest kernel (-kernel) and guest firmware (-bios, -pflash) has always been
possible to specify independently on the command line. The following cases
should be considered:
nr -bios -pflash -kernel description
unit#0
-- ------- ------- ------- -------------------------------------------
1 present present absent Board code rejects this case, -bios and
present present present -pflash unit#0 are exclusive. Left intact
by this patch.
2 absent absent present Traditional kernel loading, with qemu's
minimal board firmware. Left intact by this
patch.
3 absent present absent Preexistent case for booting guest firmware
present absent absent loaded with -bios or -pflash. Left intact
by this patch.
4 absent absent absent Preexistent case for not loading any
firmware or kernel up-front. Left intact by
this patch.
5 present absent present New case introduced by this patch: kernel
absent present present image is passed to externally loaded
firmware in unmodified form, using fw_cfg.
An easy way to see that this patch doesn't interfere with existing cases
is to realize that "info->firmware_loaded" is constant zero at this point.
Which makes the "outer" condition unchanged, and the "inner" condition
(with the fw_cfg-related code) dead.
Signed-off-by: Laszlo Ersek <lersek@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 1419250305-31062-11-git-send-email-pbonzini@redhat.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2014-12-22 13:11:44 +01:00
|
|
|
/* If we have a device tree blob, but no kernel to supply it to (or
|
|
|
|
* the kernel is supposed to be loaded by the bootloader), copy the
|
|
|
|
* DTB to the base of RAM for the bootloader to pick up.
|
2014-09-12 15:06:50 +02:00
|
|
|
*/
|
2018-05-10 19:10:56 +02:00
|
|
|
info->dtb_start = info->loader_start;
|
2014-09-12 15:06:50 +02:00
|
|
|
}
|
|
|
|
|
hw/arm: pass pristine kernel image to guest firmware over fw_cfg
Introduce the new boolean field "arm_boot_info.firmware_loaded". When this
field is set, it means that the portion of guest DRAM that the VCPU
normally starts to execute, or the pflash chip that the VCPU normally
starts to execute, has been populated by board-specific code with
full-fledged guest firmware code, before the board calls
arm_load_kernel().
Simultaneously, "arm_boot_info.firmware_loaded" guarantees that the board
code has set up the global firmware config instance, for arm_load_kernel()
to find with fw_cfg_find().
Guest kernel (-kernel) and guest firmware (-bios, -pflash) has always been
possible to specify independently on the command line. The following cases
should be considered:
nr -bios -pflash -kernel description
unit#0
-- ------- ------- ------- -------------------------------------------
1 present present absent Board code rejects this case, -bios and
present present present -pflash unit#0 are exclusive. Left intact
by this patch.
2 absent absent present Traditional kernel loading, with qemu's
minimal board firmware. Left intact by this
patch.
3 absent present absent Preexistent case for booting guest firmware
present absent absent loaded with -bios or -pflash. Left intact
by this patch.
4 absent absent absent Preexistent case for not loading any
firmware or kernel up-front. Left intact by
this patch.
5 present absent present New case introduced by this patch: kernel
absent present present image is passed to externally loaded
firmware in unmodified form, using fw_cfg.
An easy way to see that this patch doesn't interfere with existing cases
is to realize that "info->firmware_loaded" is constant zero at this point.
Which makes the "outer" condition unchanged, and the "inner" condition
(with the fw_cfg-related code) dead.
Signed-off-by: Laszlo Ersek <lersek@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 1419250305-31062-11-git-send-email-pbonzini@redhat.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2014-12-22 13:11:44 +01:00
|
|
|
if (info->kernel_filename) {
|
|
|
|
FWCfgState *fw_cfg;
|
|
|
|
bool try_decompressing_kernel;
|
|
|
|
|
|
|
|
fw_cfg = fw_cfg_find();
|
|
|
|
try_decompressing_kernel = arm_feature(&cpu->env,
|
|
|
|
ARM_FEATURE_AARCH64);
|
|
|
|
|
|
|
|
/* Expose the kernel, the command line, and the initrd in fw_cfg.
|
|
|
|
* We don't process them here at all, it's all left to the
|
|
|
|
* firmware.
|
|
|
|
*/
|
|
|
|
load_image_to_fw_cfg(fw_cfg,
|
|
|
|
FW_CFG_KERNEL_SIZE, FW_CFG_KERNEL_DATA,
|
|
|
|
info->kernel_filename,
|
|
|
|
try_decompressing_kernel);
|
|
|
|
load_image_to_fw_cfg(fw_cfg,
|
|
|
|
FW_CFG_INITRD_SIZE, FW_CFG_INITRD_DATA,
|
|
|
|
info->initrd_filename, false);
|
|
|
|
|
|
|
|
if (info->kernel_cmdline) {
|
|
|
|
fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_SIZE,
|
|
|
|
strlen(info->kernel_cmdline) + 1);
|
|
|
|
fw_cfg_add_string(fw_cfg, FW_CFG_CMDLINE_DATA,
|
|
|
|
info->kernel_cmdline);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We will start from address 0 (typically a boot ROM image) in the
|
|
|
|
* same way as hardware.
|
2013-10-25 16:44:38 +02:00
|
|
|
*/
|
|
|
|
return;
|
2006-04-28 01:15:07 +02:00
|
|
|
}
|
2007-01-16 19:54:31 +01:00
|
|
|
|
2013-12-17 20:42:30 +01:00
|
|
|
if (arm_feature(&cpu->env, ARM_FEATURE_AARCH64)) {
|
|
|
|
primary_loader = bootloader_aarch64;
|
2014-03-21 19:44:36 +01:00
|
|
|
elf_machine = EM_AARCH64;
|
2013-12-17 20:42:30 +01:00
|
|
|
} else {
|
|
|
|
primary_loader = bootloader;
|
2015-11-03 14:49:41 +01:00
|
|
|
if (!info->write_board_setup) {
|
|
|
|
primary_loader += BOOTLOADER_NO_BOARD_SETUP_OFFSET;
|
|
|
|
}
|
2014-03-21 19:44:36 +01:00
|
|
|
elf_machine = EM_ARM;
|
2013-12-17 20:42:30 +01:00
|
|
|
}
|
|
|
|
|
2012-01-26 12:43:48 +01:00
|
|
|
if (!info->secondary_cpu_reset_hook) {
|
|
|
|
info->secondary_cpu_reset_hook = default_reset_secondary;
|
|
|
|
}
|
|
|
|
if (!info->write_secondary_boot) {
|
|
|
|
info->write_secondary_boot = default_write_secondary;
|
|
|
|
}
|
|
|
|
|
2009-11-11 19:07:53 +01:00
|
|
|
if (info->nb_cpus == 0)
|
|
|
|
info->nb_cpus = 1;
|
2008-04-14 22:27:51 +02:00
|
|
|
|
2012-10-26 17:29:38 +02:00
|
|
|
/* We want to put the initrd far enough into RAM that when the
|
|
|
|
* kernel is uncompressed it will not clobber the initrd. However
|
|
|
|
* on boards without much RAM we must ensure that we still leave
|
|
|
|
* enough room for a decent sized initrd, and on boards with large
|
|
|
|
* amounts of RAM we must avoid the initrd being so far up in RAM
|
|
|
|
* that it is outside lowmem and inaccessible to the kernel.
|
|
|
|
* So for boards with less than 256MB of RAM we put the initrd
|
|
|
|
* halfway into RAM, and for boards with 256MB of RAM or more we put
|
|
|
|
* the initrd at 128MB.
|
|
|
|
*/
|
|
|
|
info->initrd_start = info->loader_start +
|
|
|
|
MIN(info->ram_size / 2, 128 * 1024 * 1024);
|
|
|
|
|
2007-03-07 00:52:01 +01:00
|
|
|
/* Assume that raw images are linux kernels, and ELF images are not. */
|
2016-03-04 12:30:21 +01:00
|
|
|
kernel_size = arm_load_elf(info, &elf_entry, &elf_low_addr,
|
2018-03-02 11:45:36 +01:00
|
|
|
&elf_high_addr, elf_machine, as);
|
2014-09-12 15:06:50 +02:00
|
|
|
if (kernel_size > 0 && have_dtb(info)) {
|
|
|
|
/* If there is still some room left at the base of RAM, try and put
|
|
|
|
* the DTB there like we do for images loaded with -bios or -pflash.
|
|
|
|
*/
|
|
|
|
if (elf_low_addr > info->loader_start
|
|
|
|
|| elf_high_addr < info->loader_start) {
|
2018-05-10 19:10:56 +02:00
|
|
|
/* Set elf_low_addr as address limit for arm_load_dtb if it may be
|
2014-09-12 15:06:50 +02:00
|
|
|
* pointing into RAM, otherwise pass '0' (no limit)
|
|
|
|
*/
|
|
|
|
if (elf_low_addr < info->loader_start) {
|
|
|
|
elf_low_addr = 0;
|
|
|
|
}
|
2018-05-10 19:10:56 +02:00
|
|
|
info->dtb_start = info->loader_start;
|
|
|
|
info->dtb_limit = elf_low_addr;
|
2014-09-12 15:06:50 +02:00
|
|
|
}
|
|
|
|
}
|
2007-03-07 00:52:01 +01:00
|
|
|
entry = elf_entry;
|
|
|
|
if (kernel_size < 0) {
|
2018-03-02 11:45:36 +01:00
|
|
|
kernel_size = load_uimage_as(info->kernel_filename, &entry, NULL,
|
|
|
|
&is_linux, NULL, NULL, as);
|
2007-03-07 00:52:01 +01:00
|
|
|
}
|
2014-08-19 19:56:28 +02:00
|
|
|
if (arm_feature(&cpu->env, ARM_FEATURE_AARCH64) && kernel_size < 0) {
|
2017-04-20 18:32:28 +02:00
|
|
|
kernel_size = load_aarch64_image(info->kernel_filename,
|
2018-03-02 11:45:36 +01:00
|
|
|
info->loader_start, &entry, as);
|
2014-08-19 19:56:28 +02:00
|
|
|
is_linux = 1;
|
2017-04-20 18:32:28 +02:00
|
|
|
} else if (kernel_size < 0) {
|
|
|
|
/* 32-bit ARM */
|
|
|
|
entry = info->loader_start + KERNEL_LOAD_ADDR;
|
2018-03-02 11:45:36 +01:00
|
|
|
kernel_size = load_image_targphys_as(info->kernel_filename, entry,
|
|
|
|
info->ram_size - KERNEL_LOAD_ADDR,
|
|
|
|
as);
|
2007-03-07 00:52:01 +01:00
|
|
|
is_linux = 1;
|
|
|
|
}
|
|
|
|
if (kernel_size < 0) {
|
hw/arm: Replace fprintf(stderr, "*\n" with error_report()
Replace a large number of the fprintf(stderr, "*\n" calls with
error_report(). The functions were renamed with these commands and then
compiler issues where manually fixed.
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
Some lines where then manually tweaked to pass checkpatch.
The 'qemu: ' prefix was manually removed from the hw/arm/boot.c file.
Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>
Cc: qemu-arm@nongnu.org
Conversions that aren't followed by exit() dropped, because they might
be inappropriate.
Also trim trailing punctuation from error messages.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-Id: <20180203084315.20497-3-armbru@redhat.com>
2018-02-03 09:43:03 +01:00
|
|
|
error_report("could not load kernel '%s'", info->kernel_filename);
|
2007-03-07 00:52:01 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
2009-11-11 19:07:53 +01:00
|
|
|
info->entry = entry;
|
|
|
|
if (is_linux) {
|
2013-12-17 20:42:30 +01:00
|
|
|
uint32_t fixupcontext[FIXUP_MAX];
|
|
|
|
|
2008-04-14 22:27:51 +02:00
|
|
|
if (info->initrd_filename) {
|
2018-03-02 11:45:36 +01:00
|
|
|
initrd_size = load_ramdisk_as(info->initrd_filename,
|
|
|
|
info->initrd_start,
|
|
|
|
info->ram_size - info->initrd_start,
|
|
|
|
as);
|
2013-07-09 00:40:02 +02:00
|
|
|
if (initrd_size < 0) {
|
2018-03-02 11:45:36 +01:00
|
|
|
initrd_size = load_image_targphys_as(info->initrd_filename,
|
|
|
|
info->initrd_start,
|
|
|
|
info->ram_size -
|
|
|
|
info->initrd_start,
|
|
|
|
as);
|
2013-07-09 00:40:02 +02:00
|
|
|
}
|
2007-01-16 19:54:31 +01:00
|
|
|
if (initrd_size < 0) {
|
hw/arm: Replace fprintf(stderr, "*\n" with error_report()
Replace a large number of the fprintf(stderr, "*\n" calls with
error_report(). The functions were renamed with these commands and then
compiler issues where manually fixed.
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
Some lines where then manually tweaked to pass checkpatch.
The 'qemu: ' prefix was manually removed from the hw/arm/boot.c file.
Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>
Cc: qemu-arm@nongnu.org
Conversions that aren't followed by exit() dropped, because they might
be inappropriate.
Also trim trailing punctuation from error messages.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-Id: <20180203084315.20497-3-armbru@redhat.com>
2018-02-03 09:43:03 +01:00
|
|
|
error_report("could not load initrd '%s'",
|
|
|
|
info->initrd_filename);
|
2007-01-16 19:54:31 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
initrd_size = 0;
|
|
|
|
}
|
2012-03-02 12:56:38 +01:00
|
|
|
info->initrd_size = initrd_size;
|
|
|
|
|
2013-12-17 20:42:30 +01:00
|
|
|
fixupcontext[FIXUP_BOARDID] = info->board_id;
|
2015-11-03 14:49:41 +01:00
|
|
|
fixupcontext[FIXUP_BOARD_SETUP] = info->board_setup_addr;
|
2012-03-02 12:56:38 +01:00
|
|
|
|
|
|
|
/* for device tree boot, we pass the DTB directly in r2. Otherwise
|
|
|
|
* we point to the kernel args.
|
|
|
|
*/
|
2014-01-31 15:47:32 +01:00
|
|
|
if (have_dtb(info)) {
|
2015-07-15 18:16:26 +02:00
|
|
|
hwaddr align;
|
|
|
|
|
|
|
|
if (elf_machine == EM_AARCH64) {
|
|
|
|
/*
|
|
|
|
* Some AArch64 kernels on early bootup map the fdt region as
|
|
|
|
*
|
|
|
|
* [ ALIGN_DOWN(fdt, 2MB) ... ALIGN_DOWN(fdt, 2MB) + 2MB ]
|
|
|
|
*
|
|
|
|
* Let's play safe and prealign it to 2MB to give us some space.
|
|
|
|
*/
|
|
|
|
align = 2 * 1024 * 1024;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Some 32bit kernels will trash anything in the 4K page the
|
|
|
|
* initrd ends in, so make sure the DTB isn't caught up in that.
|
|
|
|
*/
|
|
|
|
align = 4096;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Place the DTB after the initrd in memory with alignment. */
|
2018-05-10 19:10:56 +02:00
|
|
|
info->dtb_start = QEMU_ALIGN_UP(info->initrd_start + initrd_size,
|
|
|
|
align);
|
|
|
|
fixupcontext[FIXUP_ARGPTR] = info->dtb_start;
|
2012-03-02 12:56:38 +01:00
|
|
|
} else {
|
2013-12-17 20:42:30 +01:00
|
|
|
fixupcontext[FIXUP_ARGPTR] = info->loader_start + KERNEL_ARGS_ADDR;
|
2012-07-20 14:34:50 +02:00
|
|
|
if (info->ram_size >= (1ULL << 32)) {
|
hw/arm: Replace fprintf(stderr, "*\n" with error_report()
Replace a large number of the fprintf(stderr, "*\n" calls with
error_report(). The functions were renamed with these commands and then
compiler issues where manually fixed.
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N;N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
find ./* -type f -exec sed -i \
'N; {s|fprintf(stderr, "\(.*\)\\n"\(.*\));|error_report("\1"\2);|Ig}' \
{} +
Some lines where then manually tweaked to pass checkpatch.
The 'qemu: ' prefix was manually removed from the hw/arm/boot.c file.
Signed-off-by: Alistair Francis <alistair.francis@xilinx.com>
Cc: qemu-arm@nongnu.org
Conversions that aren't followed by exit() dropped, because they might
be inappropriate.
Also trim trailing punctuation from error messages.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-Id: <20180203084315.20497-3-armbru@redhat.com>
2018-02-03 09:43:03 +01:00
|
|
|
error_report("RAM size must be less than 4GB to boot"
|
|
|
|
" Linux kernel using ATAGS (try passing a device tree"
|
|
|
|
" using -dtb)");
|
2012-07-20 14:34:50 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
2012-03-02 12:56:38 +01:00
|
|
|
}
|
2013-12-17 20:42:30 +01:00
|
|
|
fixupcontext[FIXUP_ENTRYPOINT] = entry;
|
|
|
|
|
|
|
|
write_bootloader("bootloader", info->loader_start,
|
2018-03-02 11:45:36 +01:00
|
|
|
primary_loader, fixupcontext, as);
|
2013-12-17 20:42:30 +01:00
|
|
|
|
2009-04-09 19:19:47 +02:00
|
|
|
if (info->nb_cpus > 1) {
|
2012-05-14 00:08:10 +02:00
|
|
|
info->write_secondary_boot(cpu, info);
|
2009-04-09 19:19:47 +02:00
|
|
|
}
|
2015-11-03 14:49:41 +01:00
|
|
|
if (info->write_board_setup) {
|
|
|
|
info->write_board_setup(cpu, info);
|
|
|
|
}
|
2015-09-08 18:38:43 +02:00
|
|
|
|
|
|
|
/* Notify devices which need to fake up firmware initialization
|
|
|
|
* that we're doing a direct kernel boot.
|
|
|
|
*/
|
|
|
|
object_child_foreach_recursive(object_get_root(),
|
|
|
|
do_arm_linux_init, info);
|
2006-04-28 01:15:07 +02:00
|
|
|
}
|
2009-11-11 19:07:53 +01:00
|
|
|
info->is_linux = is_linux;
|
2011-03-05 13:51:45 +01:00
|
|
|
|
2018-05-04 19:05:51 +02:00
|
|
|
for (cs = first_cpu; cs; cs = CPU_NEXT(cs)) {
|
2014-10-24 13:19:11 +02:00
|
|
|
ARM_CPU(cs)->env.boot_info = info;
|
2011-03-05 13:51:45 +01:00
|
|
|
}
|
2015-06-15 19:06:11 +02:00
|
|
|
|
2018-05-10 19:10:56 +02:00
|
|
|
if (!info->skip_dtb_autoload && have_dtb(info)) {
|
|
|
|
if (arm_load_dtb(info->dtb_start, info, info->dtb_limit, as) < 0) {
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
2015-06-02 13:29:12 +02:00
|
|
|
}
|
2015-09-08 18:38:43 +02:00
|
|
|
|
|
|
|
static const TypeInfo arm_linux_boot_if_info = {
|
|
|
|
.name = TYPE_ARM_LINUX_BOOT_IF,
|
|
|
|
.parent = TYPE_INTERFACE,
|
|
|
|
.class_size = sizeof(ARMLinuxBootIfClass),
|
|
|
|
};
|
|
|
|
|
|
|
|
static void arm_linux_boot_register_types(void)
|
|
|
|
{
|
|
|
|
type_register_static(&arm_linux_boot_if_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
type_init(arm_linux_boot_register_types)
|