1549e984eSSergio Lopez /* 2549e984eSSergio Lopez * Copyright (c) 2003-2004 Fabrice Bellard 3549e984eSSergio Lopez * Copyright (c) 2019 Red Hat, Inc. 4549e984eSSergio Lopez * 5549e984eSSergio Lopez * Permission is hereby granted, free of charge, to any person obtaining a copy 6549e984eSSergio Lopez * of this software and associated documentation files (the "Software"), to deal 7549e984eSSergio Lopez * in the Software without restriction, including without limitation the rights 8549e984eSSergio Lopez * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9549e984eSSergio Lopez * copies of the Software, and to permit persons to whom the Software is 10549e984eSSergio Lopez * furnished to do so, subject to the following conditions: 11549e984eSSergio Lopez * 12549e984eSSergio Lopez * The above copyright notice and this permission notice shall be included in 13549e984eSSergio Lopez * all copies or substantial portions of the Software. 14549e984eSSergio Lopez * 15549e984eSSergio Lopez * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16549e984eSSergio Lopez * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17549e984eSSergio Lopez * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18549e984eSSergio Lopez * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19549e984eSSergio Lopez * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20549e984eSSergio Lopez * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21549e984eSSergio Lopez * THE SOFTWARE. 22549e984eSSergio Lopez */ 23549e984eSSergio Lopez #include "qemu/osdep.h" 24549e984eSSergio Lopez #include "qemu/error-report.h" 25549e984eSSergio Lopez #include "qemu/option.h" 26549e984eSSergio Lopez #include "qemu/cutils.h" 27549e984eSSergio Lopez #include "qemu/units.h" 28549e984eSSergio Lopez #include "qemu-common.h" 29549e984eSSergio Lopez #include "qapi/error.h" 30549e984eSSergio Lopez #include "qapi/qmp/qerror.h" 31549e984eSSergio Lopez #include "qapi/qapi-visit-common.h" 32549e984eSSergio Lopez #include "qapi/visitor.h" 33549e984eSSergio Lopez #include "sysemu/qtest.h" 34549e984eSSergio Lopez #include "sysemu/numa.h" 35549e984eSSergio Lopez #include "sysemu/replay.h" 36549e984eSSergio Lopez #include "sysemu/sysemu.h" 37549e984eSSergio Lopez 38549e984eSSergio Lopez #include "hw/i386/x86.h" 39549e984eSSergio Lopez #include "target/i386/cpu.h" 40549e984eSSergio Lopez #include "hw/i386/topology.h" 41549e984eSSergio Lopez #include "hw/i386/fw_cfg.h" 42549e984eSSergio Lopez 43549e984eSSergio Lopez #include "hw/acpi/cpu_hotplug.h" 44549e984eSSergio Lopez #include "hw/nmi.h" 45549e984eSSergio Lopez #include "hw/loader.h" 46549e984eSSergio Lopez #include "multiboot.h" 47549e984eSSergio Lopez #include "elf.h" 48549e984eSSergio Lopez #include "standard-headers/asm-x86/bootparam.h" 49549e984eSSergio Lopez 50549e984eSSergio Lopez #define BIOS_FILENAME "bios.bin" 51549e984eSSergio Lopez 52549e984eSSergio Lopez /* Physical Address of PVH entry point read from kernel ELF NOTE */ 53549e984eSSergio Lopez static size_t pvh_start_addr; 54549e984eSSergio Lopez 55549e984eSSergio Lopez /* 56549e984eSSergio Lopez * Calculates initial APIC ID for a specific CPU index 57549e984eSSergio Lopez * 58549e984eSSergio Lopez * Currently we need to be able to calculate the APIC ID from the CPU index 59549e984eSSergio Lopez * alone (without requiring a CPU object), as the QEMU<->Seabios interfaces have 60549e984eSSergio Lopez * no concept of "CPU index", and the NUMA tables on fw_cfg need the APIC ID of 61549e984eSSergio Lopez * all CPUs up to max_cpus. 62549e984eSSergio Lopez */ 63703a548aSSergio Lopez uint32_t x86_cpu_apic_id_from_index(X86MachineState *x86ms, 64549e984eSSergio Lopez unsigned int cpu_index) 65549e984eSSergio Lopez { 66703a548aSSergio Lopez MachineState *ms = MACHINE(x86ms); 67f0bb276bSPaolo Bonzini X86MachineClass *x86mc = X86_MACHINE_GET_CLASS(x86ms); 68549e984eSSergio Lopez uint32_t correct_id; 69549e984eSSergio Lopez static bool warned; 70549e984eSSergio Lopez 71f0bb276bSPaolo Bonzini correct_id = x86_apicid_from_cpu_idx(x86ms->smp_dies, ms->smp.cores, 72549e984eSSergio Lopez ms->smp.threads, cpu_index); 73f0bb276bSPaolo Bonzini if (x86mc->compat_apic_id_mode) { 74549e984eSSergio Lopez if (cpu_index != correct_id && !warned && !qtest_enabled()) { 75549e984eSSergio Lopez error_report("APIC IDs set in compatibility mode, " 76549e984eSSergio Lopez "CPU topology won't match the configuration"); 77549e984eSSergio Lopez warned = true; 78549e984eSSergio Lopez } 79549e984eSSergio Lopez return cpu_index; 80549e984eSSergio Lopez } else { 81549e984eSSergio Lopez return correct_id; 82549e984eSSergio Lopez } 83549e984eSSergio Lopez } 84549e984eSSergio Lopez 85703a548aSSergio Lopez 86703a548aSSergio Lopez void x86_cpu_new(X86MachineState *x86ms, int64_t apic_id, Error **errp) 87549e984eSSergio Lopez { 88549e984eSSergio Lopez Object *cpu = NULL; 89549e984eSSergio Lopez Error *local_err = NULL; 90549e984eSSergio Lopez CPUX86State *env = NULL; 91549e984eSSergio Lopez 92703a548aSSergio Lopez cpu = object_new(MACHINE(x86ms)->cpu_type); 93549e984eSSergio Lopez 94549e984eSSergio Lopez env = &X86_CPU(cpu)->env; 95f0bb276bSPaolo Bonzini env->nr_dies = x86ms->smp_dies; 96549e984eSSergio Lopez 97549e984eSSergio Lopez object_property_set_uint(cpu, apic_id, "apic-id", &local_err); 98549e984eSSergio Lopez object_property_set_bool(cpu, true, "realized", &local_err); 99549e984eSSergio Lopez 100549e984eSSergio Lopez object_unref(cpu); 101549e984eSSergio Lopez error_propagate(errp, local_err); 102549e984eSSergio Lopez } 103549e984eSSergio Lopez 104703a548aSSergio Lopez void x86_cpus_init(X86MachineState *x86ms, int default_cpu_version) 105549e984eSSergio Lopez { 106549e984eSSergio Lopez int i; 107549e984eSSergio Lopez const CPUArchIdList *possible_cpus; 108703a548aSSergio Lopez MachineState *ms = MACHINE(x86ms); 109703a548aSSergio Lopez MachineClass *mc = MACHINE_GET_CLASS(x86ms); 110549e984eSSergio Lopez 111703a548aSSergio Lopez x86_cpu_set_default_version(default_cpu_version); 112549e984eSSergio Lopez 113549e984eSSergio Lopez /* 114549e984eSSergio Lopez * Calculates the limit to CPU APIC ID values 115549e984eSSergio Lopez * 116549e984eSSergio Lopez * Limit for the APIC ID value, so that all 117703a548aSSergio Lopez * CPU APIC IDs are < x86ms->apic_id_limit. 118549e984eSSergio Lopez * 119549e984eSSergio Lopez * This is used for FW_CFG_MAX_CPUS. See comments on fw_cfg_arch_create(). 120549e984eSSergio Lopez */ 121703a548aSSergio Lopez x86ms->apic_id_limit = x86_cpu_apic_id_from_index(x86ms, 122549e984eSSergio Lopez ms->smp.max_cpus - 1) + 1; 123549e984eSSergio Lopez possible_cpus = mc->possible_cpu_arch_ids(ms); 124549e984eSSergio Lopez for (i = 0; i < ms->smp.cpus; i++) { 125703a548aSSergio Lopez x86_cpu_new(x86ms, possible_cpus->cpus[i].arch_id, &error_fatal); 126549e984eSSergio Lopez } 127549e984eSSergio Lopez } 128549e984eSSergio Lopez 129549e984eSSergio Lopez CpuInstanceProperties 130549e984eSSergio Lopez x86_cpu_index_to_props(MachineState *ms, unsigned cpu_index) 131549e984eSSergio Lopez { 132549e984eSSergio Lopez MachineClass *mc = MACHINE_GET_CLASS(ms); 133549e984eSSergio Lopez const CPUArchIdList *possible_cpus = mc->possible_cpu_arch_ids(ms); 134549e984eSSergio Lopez 135549e984eSSergio Lopez assert(cpu_index < possible_cpus->len); 136549e984eSSergio Lopez return possible_cpus->cpus[cpu_index].props; 137549e984eSSergio Lopez } 138549e984eSSergio Lopez 139549e984eSSergio Lopez int64_t x86_get_default_cpu_node_id(const MachineState *ms, int idx) 140549e984eSSergio Lopez { 141549e984eSSergio Lopez X86CPUTopoInfo topo; 142f0bb276bSPaolo Bonzini X86MachineState *x86ms = X86_MACHINE(ms); 143549e984eSSergio Lopez 144549e984eSSergio Lopez assert(idx < ms->possible_cpus->len); 145549e984eSSergio Lopez x86_topo_ids_from_apicid(ms->possible_cpus->cpus[idx].arch_id, 146f0bb276bSPaolo Bonzini x86ms->smp_dies, ms->smp.cores, 147549e984eSSergio Lopez ms->smp.threads, &topo); 148549e984eSSergio Lopez return topo.pkg_id % ms->numa_state->num_nodes; 149549e984eSSergio Lopez } 150549e984eSSergio Lopez 151549e984eSSergio Lopez const CPUArchIdList *x86_possible_cpu_arch_ids(MachineState *ms) 152549e984eSSergio Lopez { 153f0bb276bSPaolo Bonzini X86MachineState *x86ms = X86_MACHINE(ms); 154549e984eSSergio Lopez int i; 155549e984eSSergio Lopez unsigned int max_cpus = ms->smp.max_cpus; 156549e984eSSergio Lopez 157549e984eSSergio Lopez if (ms->possible_cpus) { 158549e984eSSergio Lopez /* 159549e984eSSergio Lopez * make sure that max_cpus hasn't changed since the first use, i.e. 160549e984eSSergio Lopez * -smp hasn't been parsed after it 161549e984eSSergio Lopez */ 162549e984eSSergio Lopez assert(ms->possible_cpus->len == max_cpus); 163549e984eSSergio Lopez return ms->possible_cpus; 164549e984eSSergio Lopez } 165549e984eSSergio Lopez 166549e984eSSergio Lopez ms->possible_cpus = g_malloc0(sizeof(CPUArchIdList) + 167549e984eSSergio Lopez sizeof(CPUArchId) * max_cpus); 168549e984eSSergio Lopez ms->possible_cpus->len = max_cpus; 169549e984eSSergio Lopez for (i = 0; i < ms->possible_cpus->len; i++) { 170549e984eSSergio Lopez X86CPUTopoInfo topo; 171549e984eSSergio Lopez 172549e984eSSergio Lopez ms->possible_cpus->cpus[i].type = ms->cpu_type; 173549e984eSSergio Lopez ms->possible_cpus->cpus[i].vcpus_count = 1; 174549e984eSSergio Lopez ms->possible_cpus->cpus[i].arch_id = 175703a548aSSergio Lopez x86_cpu_apic_id_from_index(x86ms, i); 176549e984eSSergio Lopez x86_topo_ids_from_apicid(ms->possible_cpus->cpus[i].arch_id, 177f0bb276bSPaolo Bonzini x86ms->smp_dies, ms->smp.cores, 178549e984eSSergio Lopez ms->smp.threads, &topo); 179549e984eSSergio Lopez ms->possible_cpus->cpus[i].props.has_socket_id = true; 180549e984eSSergio Lopez ms->possible_cpus->cpus[i].props.socket_id = topo.pkg_id; 181f0bb276bSPaolo Bonzini if (x86ms->smp_dies > 1) { 182549e984eSSergio Lopez ms->possible_cpus->cpus[i].props.has_die_id = true; 183549e984eSSergio Lopez ms->possible_cpus->cpus[i].props.die_id = topo.die_id; 184549e984eSSergio Lopez } 185549e984eSSergio Lopez ms->possible_cpus->cpus[i].props.has_core_id = true; 186549e984eSSergio Lopez ms->possible_cpus->cpus[i].props.core_id = topo.core_id; 187549e984eSSergio Lopez ms->possible_cpus->cpus[i].props.has_thread_id = true; 188549e984eSSergio Lopez ms->possible_cpus->cpus[i].props.thread_id = topo.smt_id; 189549e984eSSergio Lopez } 190549e984eSSergio Lopez return ms->possible_cpus; 191549e984eSSergio Lopez } 192549e984eSSergio Lopez 193f0bb276bSPaolo Bonzini static void x86_nmi(NMIState *n, int cpu_index, Error **errp) 194f0bb276bSPaolo Bonzini { 195f0bb276bSPaolo Bonzini /* cpu index isn't used */ 196f0bb276bSPaolo Bonzini CPUState *cs; 197f0bb276bSPaolo Bonzini 198f0bb276bSPaolo Bonzini CPU_FOREACH(cs) { 199f0bb276bSPaolo Bonzini X86CPU *cpu = X86_CPU(cs); 200f0bb276bSPaolo Bonzini 201f0bb276bSPaolo Bonzini if (!cpu->apic_state) { 202f0bb276bSPaolo Bonzini cpu_interrupt(cs, CPU_INTERRUPT_NMI); 203f0bb276bSPaolo Bonzini } else { 204f0bb276bSPaolo Bonzini apic_deliver_nmi(cpu->apic_state); 205f0bb276bSPaolo Bonzini } 206f0bb276bSPaolo Bonzini } 207f0bb276bSPaolo Bonzini } 208f0bb276bSPaolo Bonzini 209549e984eSSergio Lopez static long get_file_size(FILE *f) 210549e984eSSergio Lopez { 211549e984eSSergio Lopez long where, size; 212549e984eSSergio Lopez 213549e984eSSergio Lopez /* XXX: on Unix systems, using fstat() probably makes more sense */ 214549e984eSSergio Lopez 215549e984eSSergio Lopez where = ftell(f); 216549e984eSSergio Lopez fseek(f, 0, SEEK_END); 217549e984eSSergio Lopez size = ftell(f); 218549e984eSSergio Lopez fseek(f, where, SEEK_SET); 219549e984eSSergio Lopez 220549e984eSSergio Lopez return size; 221549e984eSSergio Lopez } 222549e984eSSergio Lopez 223549e984eSSergio Lopez struct setup_data { 224549e984eSSergio Lopez uint64_t next; 225549e984eSSergio Lopez uint32_t type; 226549e984eSSergio Lopez uint32_t len; 227549e984eSSergio Lopez uint8_t data[0]; 228549e984eSSergio Lopez } __attribute__((packed)); 229549e984eSSergio Lopez 230549e984eSSergio Lopez 231549e984eSSergio Lopez /* 232549e984eSSergio Lopez * The entry point into the kernel for PVH boot is different from 233549e984eSSergio Lopez * the native entry point. The PVH entry is defined by the x86/HVM 234549e984eSSergio Lopez * direct boot ABI and is available in an ELFNOTE in the kernel binary. 235549e984eSSergio Lopez * 236549e984eSSergio Lopez * This function is passed to load_elf() when it is called from 237549e984eSSergio Lopez * load_elfboot() which then additionally checks for an ELF Note of 238549e984eSSergio Lopez * type XEN_ELFNOTE_PHYS32_ENTRY and passes it to this function to 239549e984eSSergio Lopez * parse the PVH entry address from the ELF Note. 240549e984eSSergio Lopez * 241549e984eSSergio Lopez * Due to trickery in elf_opts.h, load_elf() is actually available as 242549e984eSSergio Lopez * load_elf32() or load_elf64() and this routine needs to be able 243549e984eSSergio Lopez * to deal with being called as 32 or 64 bit. 244549e984eSSergio Lopez * 245549e984eSSergio Lopez * The address of the PVH entry point is saved to the 'pvh_start_addr' 246549e984eSSergio Lopez * global variable. (although the entry point is 32-bit, the kernel 247549e984eSSergio Lopez * binary can be either 32-bit or 64-bit). 248549e984eSSergio Lopez */ 249549e984eSSergio Lopez static uint64_t read_pvh_start_addr(void *arg1, void *arg2, bool is64) 250549e984eSSergio Lopez { 251549e984eSSergio Lopez size_t *elf_note_data_addr; 252549e984eSSergio Lopez 253549e984eSSergio Lopez /* Check if ELF Note header passed in is valid */ 254549e984eSSergio Lopez if (arg1 == NULL) { 255549e984eSSergio Lopez return 0; 256549e984eSSergio Lopez } 257549e984eSSergio Lopez 258549e984eSSergio Lopez if (is64) { 259549e984eSSergio Lopez struct elf64_note *nhdr64 = (struct elf64_note *)arg1; 260549e984eSSergio Lopez uint64_t nhdr_size64 = sizeof(struct elf64_note); 261549e984eSSergio Lopez uint64_t phdr_align = *(uint64_t *)arg2; 262549e984eSSergio Lopez uint64_t nhdr_namesz = nhdr64->n_namesz; 263549e984eSSergio Lopez 264549e984eSSergio Lopez elf_note_data_addr = 265549e984eSSergio Lopez ((void *)nhdr64) + nhdr_size64 + 266549e984eSSergio Lopez QEMU_ALIGN_UP(nhdr_namesz, phdr_align); 267549e984eSSergio Lopez } else { 268549e984eSSergio Lopez struct elf32_note *nhdr32 = (struct elf32_note *)arg1; 269549e984eSSergio Lopez uint32_t nhdr_size32 = sizeof(struct elf32_note); 270549e984eSSergio Lopez uint32_t phdr_align = *(uint32_t *)arg2; 271549e984eSSergio Lopez uint32_t nhdr_namesz = nhdr32->n_namesz; 272549e984eSSergio Lopez 273549e984eSSergio Lopez elf_note_data_addr = 274549e984eSSergio Lopez ((void *)nhdr32) + nhdr_size32 + 275549e984eSSergio Lopez QEMU_ALIGN_UP(nhdr_namesz, phdr_align); 276549e984eSSergio Lopez } 277549e984eSSergio Lopez 278549e984eSSergio Lopez pvh_start_addr = *elf_note_data_addr; 279549e984eSSergio Lopez 280549e984eSSergio Lopez return pvh_start_addr; 281549e984eSSergio Lopez } 282549e984eSSergio Lopez 283549e984eSSergio Lopez static bool load_elfboot(const char *kernel_filename, 284549e984eSSergio Lopez int kernel_file_size, 285549e984eSSergio Lopez uint8_t *header, 286549e984eSSergio Lopez size_t pvh_xen_start_addr, 287549e984eSSergio Lopez FWCfgState *fw_cfg) 288549e984eSSergio Lopez { 289549e984eSSergio Lopez uint32_t flags = 0; 290549e984eSSergio Lopez uint32_t mh_load_addr = 0; 291549e984eSSergio Lopez uint32_t elf_kernel_size = 0; 292549e984eSSergio Lopez uint64_t elf_entry; 293549e984eSSergio Lopez uint64_t elf_low, elf_high; 294549e984eSSergio Lopez int kernel_size; 295549e984eSSergio Lopez 296549e984eSSergio Lopez if (ldl_p(header) != 0x464c457f) { 297549e984eSSergio Lopez return false; /* no elfboot */ 298549e984eSSergio Lopez } 299549e984eSSergio Lopez 300549e984eSSergio Lopez bool elf_is64 = header[EI_CLASS] == ELFCLASS64; 301549e984eSSergio Lopez flags = elf_is64 ? 302549e984eSSergio Lopez ((Elf64_Ehdr *)header)->e_flags : ((Elf32_Ehdr *)header)->e_flags; 303549e984eSSergio Lopez 304549e984eSSergio Lopez if (flags & 0x00010004) { /* LOAD_ELF_HEADER_HAS_ADDR */ 305549e984eSSergio Lopez error_report("elfboot unsupported flags = %x", flags); 306549e984eSSergio Lopez exit(1); 307549e984eSSergio Lopez } 308549e984eSSergio Lopez 309549e984eSSergio Lopez uint64_t elf_note_type = XEN_ELFNOTE_PHYS32_ENTRY; 310549e984eSSergio Lopez kernel_size = load_elf(kernel_filename, read_pvh_start_addr, 311549e984eSSergio Lopez NULL, &elf_note_type, &elf_entry, 312549e984eSSergio Lopez &elf_low, &elf_high, 0, I386_ELF_MACHINE, 313549e984eSSergio Lopez 0, 0); 314549e984eSSergio Lopez 315549e984eSSergio Lopez if (kernel_size < 0) { 316549e984eSSergio Lopez error_report("Error while loading elf kernel"); 317549e984eSSergio Lopez exit(1); 318549e984eSSergio Lopez } 319549e984eSSergio Lopez mh_load_addr = elf_low; 320549e984eSSergio Lopez elf_kernel_size = elf_high - elf_low; 321549e984eSSergio Lopez 322549e984eSSergio Lopez if (pvh_start_addr == 0) { 323549e984eSSergio Lopez error_report("Error loading uncompressed kernel without PVH ELF Note"); 324549e984eSSergio Lopez exit(1); 325549e984eSSergio Lopez } 326549e984eSSergio Lopez fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ENTRY, pvh_start_addr); 327549e984eSSergio Lopez fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, mh_load_addr); 328549e984eSSergio Lopez fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, elf_kernel_size); 329549e984eSSergio Lopez 330549e984eSSergio Lopez return true; 331549e984eSSergio Lopez } 332549e984eSSergio Lopez 333703a548aSSergio Lopez void x86_load_linux(X86MachineState *x86ms, 334703a548aSSergio Lopez FWCfgState *fw_cfg, 335703a548aSSergio Lopez int acpi_data_size, 336703a548aSSergio Lopez bool pvh_enabled, 337703a548aSSergio Lopez bool linuxboot_dma_enabled) 338549e984eSSergio Lopez { 339549e984eSSergio Lopez uint16_t protocol; 340549e984eSSergio Lopez int setup_size, kernel_size, cmdline_size; 341549e984eSSergio Lopez int dtb_size, setup_data_offset; 342549e984eSSergio Lopez uint32_t initrd_max; 343549e984eSSergio Lopez uint8_t header[8192], *setup, *kernel; 344549e984eSSergio Lopez hwaddr real_addr, prot_addr, cmdline_addr, initrd_addr = 0; 345549e984eSSergio Lopez FILE *f; 346549e984eSSergio Lopez char *vmode; 347703a548aSSergio Lopez MachineState *machine = MACHINE(x86ms); 348549e984eSSergio Lopez struct setup_data *setup_data; 349549e984eSSergio Lopez const char *kernel_filename = machine->kernel_filename; 350549e984eSSergio Lopez const char *initrd_filename = machine->initrd_filename; 351549e984eSSergio Lopez const char *dtb_filename = machine->dtb; 352549e984eSSergio Lopez const char *kernel_cmdline = machine->kernel_cmdline; 353549e984eSSergio Lopez 354549e984eSSergio Lopez /* Align to 16 bytes as a paranoia measure */ 355549e984eSSergio Lopez cmdline_size = (strlen(kernel_cmdline) + 16) & ~15; 356549e984eSSergio Lopez 357549e984eSSergio Lopez /* load the kernel header */ 358549e984eSSergio Lopez f = fopen(kernel_filename, "rb"); 359549e984eSSergio Lopez if (!f) { 360549e984eSSergio Lopez fprintf(stderr, "qemu: could not open kernel file '%s': %s\n", 361549e984eSSergio Lopez kernel_filename, strerror(errno)); 362549e984eSSergio Lopez exit(1); 363549e984eSSergio Lopez } 364549e984eSSergio Lopez 365549e984eSSergio Lopez kernel_size = get_file_size(f); 366549e984eSSergio Lopez if (!kernel_size || 367549e984eSSergio Lopez fread(header, 1, MIN(ARRAY_SIZE(header), kernel_size), f) != 368549e984eSSergio Lopez MIN(ARRAY_SIZE(header), kernel_size)) { 369549e984eSSergio Lopez fprintf(stderr, "qemu: could not load kernel '%s': %s\n", 370549e984eSSergio Lopez kernel_filename, strerror(errno)); 371549e984eSSergio Lopez exit(1); 372549e984eSSergio Lopez } 373549e984eSSergio Lopez 374549e984eSSergio Lopez /* kernel protocol version */ 375549e984eSSergio Lopez if (ldl_p(header + 0x202) == 0x53726448) { 376549e984eSSergio Lopez protocol = lduw_p(header + 0x206); 377549e984eSSergio Lopez } else { 378549e984eSSergio Lopez /* 379549e984eSSergio Lopez * This could be a multiboot kernel. If it is, let's stop treating it 380549e984eSSergio Lopez * like a Linux kernel. 381549e984eSSergio Lopez * Note: some multiboot images could be in the ELF format (the same of 382549e984eSSergio Lopez * PVH), so we try multiboot first since we check the multiboot magic 383549e984eSSergio Lopez * header before to load it. 384549e984eSSergio Lopez */ 385549e984eSSergio Lopez if (load_multiboot(fw_cfg, f, kernel_filename, initrd_filename, 386549e984eSSergio Lopez kernel_cmdline, kernel_size, header)) { 387549e984eSSergio Lopez return; 388549e984eSSergio Lopez } 389549e984eSSergio Lopez /* 390549e984eSSergio Lopez * Check if the file is an uncompressed kernel file (ELF) and load it, 391549e984eSSergio Lopez * saving the PVH entry point used by the x86/HVM direct boot ABI. 392549e984eSSergio Lopez * If load_elfboot() is successful, populate the fw_cfg info. 393549e984eSSergio Lopez */ 394703a548aSSergio Lopez if (pvh_enabled && 395549e984eSSergio Lopez load_elfboot(kernel_filename, kernel_size, 396549e984eSSergio Lopez header, pvh_start_addr, fw_cfg)) { 397549e984eSSergio Lopez fclose(f); 398549e984eSSergio Lopez 399549e984eSSergio Lopez fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_SIZE, 400549e984eSSergio Lopez strlen(kernel_cmdline) + 1); 401549e984eSSergio Lopez fw_cfg_add_string(fw_cfg, FW_CFG_CMDLINE_DATA, kernel_cmdline); 402549e984eSSergio Lopez 403549e984eSSergio Lopez fw_cfg_add_i32(fw_cfg, FW_CFG_SETUP_SIZE, sizeof(header)); 404549e984eSSergio Lopez fw_cfg_add_bytes(fw_cfg, FW_CFG_SETUP_DATA, 405549e984eSSergio Lopez header, sizeof(header)); 406549e984eSSergio Lopez 407549e984eSSergio Lopez /* load initrd */ 408549e984eSSergio Lopez if (initrd_filename) { 409549e984eSSergio Lopez GMappedFile *mapped_file; 410549e984eSSergio Lopez gsize initrd_size; 411549e984eSSergio Lopez gchar *initrd_data; 412549e984eSSergio Lopez GError *gerr = NULL; 413549e984eSSergio Lopez 414549e984eSSergio Lopez mapped_file = g_mapped_file_new(initrd_filename, false, &gerr); 415549e984eSSergio Lopez if (!mapped_file) { 416549e984eSSergio Lopez fprintf(stderr, "qemu: error reading initrd %s: %s\n", 417549e984eSSergio Lopez initrd_filename, gerr->message); 418549e984eSSergio Lopez exit(1); 419549e984eSSergio Lopez } 420f0bb276bSPaolo Bonzini x86ms->initrd_mapped_file = mapped_file; 421549e984eSSergio Lopez 422549e984eSSergio Lopez initrd_data = g_mapped_file_get_contents(mapped_file); 423549e984eSSergio Lopez initrd_size = g_mapped_file_get_length(mapped_file); 424703a548aSSergio Lopez initrd_max = x86ms->below_4g_mem_size - acpi_data_size - 1; 425549e984eSSergio Lopez if (initrd_size >= initrd_max) { 426549e984eSSergio Lopez fprintf(stderr, "qemu: initrd is too large, cannot support." 427549e984eSSergio Lopez "(max: %"PRIu32", need %"PRId64")\n", 428549e984eSSergio Lopez initrd_max, (uint64_t)initrd_size); 429549e984eSSergio Lopez exit(1); 430549e984eSSergio Lopez } 431549e984eSSergio Lopez 432549e984eSSergio Lopez initrd_addr = (initrd_max - initrd_size) & ~4095; 433549e984eSSergio Lopez 434549e984eSSergio Lopez fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, initrd_addr); 435549e984eSSergio Lopez fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, initrd_size); 436549e984eSSergio Lopez fw_cfg_add_bytes(fw_cfg, FW_CFG_INITRD_DATA, initrd_data, 437549e984eSSergio Lopez initrd_size); 438549e984eSSergio Lopez } 439549e984eSSergio Lopez 440549e984eSSergio Lopez option_rom[nb_option_roms].bootindex = 0; 441549e984eSSergio Lopez option_rom[nb_option_roms].name = "pvh.bin"; 442549e984eSSergio Lopez nb_option_roms++; 443549e984eSSergio Lopez 444549e984eSSergio Lopez return; 445549e984eSSergio Lopez } 446549e984eSSergio Lopez protocol = 0; 447549e984eSSergio Lopez } 448549e984eSSergio Lopez 449549e984eSSergio Lopez if (protocol < 0x200 || !(header[0x211] & 0x01)) { 450549e984eSSergio Lopez /* Low kernel */ 451549e984eSSergio Lopez real_addr = 0x90000; 452549e984eSSergio Lopez cmdline_addr = 0x9a000 - cmdline_size; 453549e984eSSergio Lopez prot_addr = 0x10000; 454549e984eSSergio Lopez } else if (protocol < 0x202) { 455549e984eSSergio Lopez /* High but ancient kernel */ 456549e984eSSergio Lopez real_addr = 0x90000; 457549e984eSSergio Lopez cmdline_addr = 0x9a000 - cmdline_size; 458549e984eSSergio Lopez prot_addr = 0x100000; 459549e984eSSergio Lopez } else { 460549e984eSSergio Lopez /* High and recent kernel */ 461549e984eSSergio Lopez real_addr = 0x10000; 462549e984eSSergio Lopez cmdline_addr = 0x20000; 463549e984eSSergio Lopez prot_addr = 0x100000; 464549e984eSSergio Lopez } 465549e984eSSergio Lopez 466549e984eSSergio Lopez /* highest address for loading the initrd */ 467549e984eSSergio Lopez if (protocol >= 0x20c && 468549e984eSSergio Lopez lduw_p(header + 0x236) & XLF_CAN_BE_LOADED_ABOVE_4G) { 469549e984eSSergio Lopez /* 470549e984eSSergio Lopez * Linux has supported initrd up to 4 GB for a very long time (2007, 471549e984eSSergio Lopez * long before XLF_CAN_BE_LOADED_ABOVE_4G which was added in 2013), 472549e984eSSergio Lopez * though it only sets initrd_max to 2 GB to "work around bootloader 473549e984eSSergio Lopez * bugs". Luckily, QEMU firmware(which does something like bootloader) 474549e984eSSergio Lopez * has supported this. 475549e984eSSergio Lopez * 476549e984eSSergio Lopez * It's believed that if XLF_CAN_BE_LOADED_ABOVE_4G is set, initrd can 477549e984eSSergio Lopez * be loaded into any address. 478549e984eSSergio Lopez * 479549e984eSSergio Lopez * In addition, initrd_max is uint32_t simply because QEMU doesn't 480549e984eSSergio Lopez * support the 64-bit boot protocol (specifically the ext_ramdisk_image 481549e984eSSergio Lopez * field). 482549e984eSSergio Lopez * 483549e984eSSergio Lopez * Therefore here just limit initrd_max to UINT32_MAX simply as well. 484549e984eSSergio Lopez */ 485549e984eSSergio Lopez initrd_max = UINT32_MAX; 486549e984eSSergio Lopez } else if (protocol >= 0x203) { 487549e984eSSergio Lopez initrd_max = ldl_p(header + 0x22c); 488549e984eSSergio Lopez } else { 489549e984eSSergio Lopez initrd_max = 0x37ffffff; 490549e984eSSergio Lopez } 491549e984eSSergio Lopez 492703a548aSSergio Lopez if (initrd_max >= x86ms->below_4g_mem_size - acpi_data_size) { 493703a548aSSergio Lopez initrd_max = x86ms->below_4g_mem_size - acpi_data_size - 1; 494549e984eSSergio Lopez } 495549e984eSSergio Lopez 496549e984eSSergio Lopez fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_ADDR, cmdline_addr); 497549e984eSSergio Lopez fw_cfg_add_i32(fw_cfg, FW_CFG_CMDLINE_SIZE, strlen(kernel_cmdline) + 1); 498549e984eSSergio Lopez fw_cfg_add_string(fw_cfg, FW_CFG_CMDLINE_DATA, kernel_cmdline); 499549e984eSSergio Lopez 500549e984eSSergio Lopez if (protocol >= 0x202) { 501549e984eSSergio Lopez stl_p(header + 0x228, cmdline_addr); 502549e984eSSergio Lopez } else { 503549e984eSSergio Lopez stw_p(header + 0x20, 0xA33F); 504549e984eSSergio Lopez stw_p(header + 0x22, cmdline_addr - real_addr); 505549e984eSSergio Lopez } 506549e984eSSergio Lopez 507549e984eSSergio Lopez /* handle vga= parameter */ 508549e984eSSergio Lopez vmode = strstr(kernel_cmdline, "vga="); 509549e984eSSergio Lopez if (vmode) { 510549e984eSSergio Lopez unsigned int video_mode; 511549e984eSSergio Lopez int ret; 512549e984eSSergio Lopez /* skip "vga=" */ 513549e984eSSergio Lopez vmode += 4; 514549e984eSSergio Lopez if (!strncmp(vmode, "normal", 6)) { 515549e984eSSergio Lopez video_mode = 0xffff; 516549e984eSSergio Lopez } else if (!strncmp(vmode, "ext", 3)) { 517549e984eSSergio Lopez video_mode = 0xfffe; 518549e984eSSergio Lopez } else if (!strncmp(vmode, "ask", 3)) { 519549e984eSSergio Lopez video_mode = 0xfffd; 520549e984eSSergio Lopez } else { 521549e984eSSergio Lopez ret = qemu_strtoui(vmode, NULL, 0, &video_mode); 522549e984eSSergio Lopez if (ret != 0) { 523549e984eSSergio Lopez fprintf(stderr, "qemu: can't parse 'vga' parameter: %s\n", 524549e984eSSergio Lopez strerror(-ret)); 525549e984eSSergio Lopez exit(1); 526549e984eSSergio Lopez } 527549e984eSSergio Lopez } 528549e984eSSergio Lopez stw_p(header + 0x1fa, video_mode); 529549e984eSSergio Lopez } 530549e984eSSergio Lopez 531549e984eSSergio Lopez /* loader type */ 532549e984eSSergio Lopez /* 533549e984eSSergio Lopez * High nybble = B reserved for QEMU; low nybble is revision number. 534549e984eSSergio Lopez * If this code is substantially changed, you may want to consider 535549e984eSSergio Lopez * incrementing the revision. 536549e984eSSergio Lopez */ 537549e984eSSergio Lopez if (protocol >= 0x200) { 538549e984eSSergio Lopez header[0x210] = 0xB0; 539549e984eSSergio Lopez } 540549e984eSSergio Lopez /* heap */ 541549e984eSSergio Lopez if (protocol >= 0x201) { 542549e984eSSergio Lopez header[0x211] |= 0x80; /* CAN_USE_HEAP */ 543549e984eSSergio Lopez stw_p(header + 0x224, cmdline_addr - real_addr - 0x200); 544549e984eSSergio Lopez } 545549e984eSSergio Lopez 546549e984eSSergio Lopez /* load initrd */ 547549e984eSSergio Lopez if (initrd_filename) { 548549e984eSSergio Lopez GMappedFile *mapped_file; 549549e984eSSergio Lopez gsize initrd_size; 550549e984eSSergio Lopez gchar *initrd_data; 551549e984eSSergio Lopez GError *gerr = NULL; 552549e984eSSergio Lopez 553549e984eSSergio Lopez if (protocol < 0x200) { 554549e984eSSergio Lopez fprintf(stderr, "qemu: linux kernel too old to load a ram disk\n"); 555549e984eSSergio Lopez exit(1); 556549e984eSSergio Lopez } 557549e984eSSergio Lopez 558549e984eSSergio Lopez mapped_file = g_mapped_file_new(initrd_filename, false, &gerr); 559549e984eSSergio Lopez if (!mapped_file) { 560549e984eSSergio Lopez fprintf(stderr, "qemu: error reading initrd %s: %s\n", 561549e984eSSergio Lopez initrd_filename, gerr->message); 562549e984eSSergio Lopez exit(1); 563549e984eSSergio Lopez } 564f0bb276bSPaolo Bonzini x86ms->initrd_mapped_file = mapped_file; 565549e984eSSergio Lopez 566549e984eSSergio Lopez initrd_data = g_mapped_file_get_contents(mapped_file); 567549e984eSSergio Lopez initrd_size = g_mapped_file_get_length(mapped_file); 568549e984eSSergio Lopez if (initrd_size >= initrd_max) { 569549e984eSSergio Lopez fprintf(stderr, "qemu: initrd is too large, cannot support." 570549e984eSSergio Lopez "(max: %"PRIu32", need %"PRId64")\n", 571549e984eSSergio Lopez initrd_max, (uint64_t)initrd_size); 572549e984eSSergio Lopez exit(1); 573549e984eSSergio Lopez } 574549e984eSSergio Lopez 575549e984eSSergio Lopez initrd_addr = (initrd_max - initrd_size) & ~4095; 576549e984eSSergio Lopez 577549e984eSSergio Lopez fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, initrd_addr); 578549e984eSSergio Lopez fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, initrd_size); 579549e984eSSergio Lopez fw_cfg_add_bytes(fw_cfg, FW_CFG_INITRD_DATA, initrd_data, initrd_size); 580549e984eSSergio Lopez 581549e984eSSergio Lopez stl_p(header + 0x218, initrd_addr); 582549e984eSSergio Lopez stl_p(header + 0x21c, initrd_size); 583549e984eSSergio Lopez } 584549e984eSSergio Lopez 585549e984eSSergio Lopez /* load kernel and setup */ 586549e984eSSergio Lopez setup_size = header[0x1f1]; 587549e984eSSergio Lopez if (setup_size == 0) { 588549e984eSSergio Lopez setup_size = 4; 589549e984eSSergio Lopez } 590549e984eSSergio Lopez setup_size = (setup_size + 1) * 512; 591549e984eSSergio Lopez if (setup_size > kernel_size) { 592549e984eSSergio Lopez fprintf(stderr, "qemu: invalid kernel header\n"); 593549e984eSSergio Lopez exit(1); 594549e984eSSergio Lopez } 595549e984eSSergio Lopez kernel_size -= setup_size; 596549e984eSSergio Lopez 597549e984eSSergio Lopez setup = g_malloc(setup_size); 598549e984eSSergio Lopez kernel = g_malloc(kernel_size); 599549e984eSSergio Lopez fseek(f, 0, SEEK_SET); 600549e984eSSergio Lopez if (fread(setup, 1, setup_size, f) != setup_size) { 601549e984eSSergio Lopez fprintf(stderr, "fread() failed\n"); 602549e984eSSergio Lopez exit(1); 603549e984eSSergio Lopez } 604549e984eSSergio Lopez if (fread(kernel, 1, kernel_size, f) != kernel_size) { 605549e984eSSergio Lopez fprintf(stderr, "fread() failed\n"); 606549e984eSSergio Lopez exit(1); 607549e984eSSergio Lopez } 608549e984eSSergio Lopez fclose(f); 609549e984eSSergio Lopez 610549e984eSSergio Lopez /* append dtb to kernel */ 611549e984eSSergio Lopez if (dtb_filename) { 612549e984eSSergio Lopez if (protocol < 0x209) { 613549e984eSSergio Lopez fprintf(stderr, "qemu: Linux kernel too old to load a dtb\n"); 614549e984eSSergio Lopez exit(1); 615549e984eSSergio Lopez } 616549e984eSSergio Lopez 617549e984eSSergio Lopez dtb_size = get_image_size(dtb_filename); 618549e984eSSergio Lopez if (dtb_size <= 0) { 619549e984eSSergio Lopez fprintf(stderr, "qemu: error reading dtb %s: %s\n", 620549e984eSSergio Lopez dtb_filename, strerror(errno)); 621549e984eSSergio Lopez exit(1); 622549e984eSSergio Lopez } 623549e984eSSergio Lopez 624549e984eSSergio Lopez setup_data_offset = QEMU_ALIGN_UP(kernel_size, 16); 625549e984eSSergio Lopez kernel_size = setup_data_offset + sizeof(struct setup_data) + dtb_size; 626549e984eSSergio Lopez kernel = g_realloc(kernel, kernel_size); 627549e984eSSergio Lopez 628549e984eSSergio Lopez stq_p(header + 0x250, prot_addr + setup_data_offset); 629549e984eSSergio Lopez 630549e984eSSergio Lopez setup_data = (struct setup_data *)(kernel + setup_data_offset); 631549e984eSSergio Lopez setup_data->next = 0; 632549e984eSSergio Lopez setup_data->type = cpu_to_le32(SETUP_DTB); 633549e984eSSergio Lopez setup_data->len = cpu_to_le32(dtb_size); 634549e984eSSergio Lopez 635549e984eSSergio Lopez load_image_size(dtb_filename, setup_data->data, dtb_size); 636549e984eSSergio Lopez } 637549e984eSSergio Lopez 638549e984eSSergio Lopez memcpy(setup, header, MIN(sizeof(header), setup_size)); 639549e984eSSergio Lopez 640549e984eSSergio Lopez fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, prot_addr); 641549e984eSSergio Lopez fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, kernel_size); 642549e984eSSergio Lopez fw_cfg_add_bytes(fw_cfg, FW_CFG_KERNEL_DATA, kernel, kernel_size); 643549e984eSSergio Lopez 644549e984eSSergio Lopez fw_cfg_add_i32(fw_cfg, FW_CFG_SETUP_ADDR, real_addr); 645549e984eSSergio Lopez fw_cfg_add_i32(fw_cfg, FW_CFG_SETUP_SIZE, setup_size); 646549e984eSSergio Lopez fw_cfg_add_bytes(fw_cfg, FW_CFG_SETUP_DATA, setup, setup_size); 647549e984eSSergio Lopez 648549e984eSSergio Lopez option_rom[nb_option_roms].bootindex = 0; 649549e984eSSergio Lopez option_rom[nb_option_roms].name = "linuxboot.bin"; 650703a548aSSergio Lopez if (linuxboot_dma_enabled && fw_cfg_dma_enabled(fw_cfg)) { 651549e984eSSergio Lopez option_rom[nb_option_roms].name = "linuxboot_dma.bin"; 652549e984eSSergio Lopez } 653549e984eSSergio Lopez nb_option_roms++; 654549e984eSSergio Lopez } 655549e984eSSergio Lopez 656549e984eSSergio Lopez void x86_bios_rom_init(MemoryRegion *rom_memory, bool isapc_ram_fw) 657549e984eSSergio Lopez { 658549e984eSSergio Lopez char *filename; 659549e984eSSergio Lopez MemoryRegion *bios, *isa_bios; 660549e984eSSergio Lopez int bios_size, isa_bios_size; 661549e984eSSergio Lopez int ret; 662549e984eSSergio Lopez 663549e984eSSergio Lopez /* BIOS load */ 664549e984eSSergio Lopez if (bios_name == NULL) { 665549e984eSSergio Lopez bios_name = BIOS_FILENAME; 666549e984eSSergio Lopez } 667549e984eSSergio Lopez filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name); 668549e984eSSergio Lopez if (filename) { 669549e984eSSergio Lopez bios_size = get_image_size(filename); 670549e984eSSergio Lopez } else { 671549e984eSSergio Lopez bios_size = -1; 672549e984eSSergio Lopez } 673549e984eSSergio Lopez if (bios_size <= 0 || 674549e984eSSergio Lopez (bios_size % 65536) != 0) { 675549e984eSSergio Lopez goto bios_error; 676549e984eSSergio Lopez } 677549e984eSSergio Lopez bios = g_malloc(sizeof(*bios)); 678549e984eSSergio Lopez memory_region_init_ram(bios, NULL, "pc.bios", bios_size, &error_fatal); 679549e984eSSergio Lopez if (!isapc_ram_fw) { 680549e984eSSergio Lopez memory_region_set_readonly(bios, true); 681549e984eSSergio Lopez } 682549e984eSSergio Lopez ret = rom_add_file_fixed(bios_name, (uint32_t)(-bios_size), -1); 683549e984eSSergio Lopez if (ret != 0) { 684549e984eSSergio Lopez bios_error: 685549e984eSSergio Lopez fprintf(stderr, "qemu: could not load PC BIOS '%s'\n", bios_name); 686549e984eSSergio Lopez exit(1); 687549e984eSSergio Lopez } 688549e984eSSergio Lopez g_free(filename); 689549e984eSSergio Lopez 690549e984eSSergio Lopez /* map the last 128KB of the BIOS in ISA space */ 691549e984eSSergio Lopez isa_bios_size = MIN(bios_size, 128 * KiB); 692549e984eSSergio Lopez isa_bios = g_malloc(sizeof(*isa_bios)); 693549e984eSSergio Lopez memory_region_init_alias(isa_bios, NULL, "isa-bios", bios, 694549e984eSSergio Lopez bios_size - isa_bios_size, isa_bios_size); 695549e984eSSergio Lopez memory_region_add_subregion_overlap(rom_memory, 696549e984eSSergio Lopez 0x100000 - isa_bios_size, 697549e984eSSergio Lopez isa_bios, 698549e984eSSergio Lopez 1); 699549e984eSSergio Lopez if (!isapc_ram_fw) { 700549e984eSSergio Lopez memory_region_set_readonly(isa_bios, true); 701549e984eSSergio Lopez } 702549e984eSSergio Lopez 703549e984eSSergio Lopez /* map all the bios at the top of memory */ 704549e984eSSergio Lopez memory_region_add_subregion(rom_memory, 705549e984eSSergio Lopez (uint32_t)(-bios_size), 706549e984eSSergio Lopez bios); 707549e984eSSergio Lopez } 708f0bb276bSPaolo Bonzini 709f0bb276bSPaolo Bonzini static void x86_machine_get_max_ram_below_4g(Object *obj, Visitor *v, 710f0bb276bSPaolo Bonzini const char *name, void *opaque, 711f0bb276bSPaolo Bonzini Error **errp) 712f0bb276bSPaolo Bonzini { 713f0bb276bSPaolo Bonzini X86MachineState *x86ms = X86_MACHINE(obj); 714f0bb276bSPaolo Bonzini uint64_t value = x86ms->max_ram_below_4g; 715f0bb276bSPaolo Bonzini 716f0bb276bSPaolo Bonzini visit_type_size(v, name, &value, errp); 717f0bb276bSPaolo Bonzini } 718f0bb276bSPaolo Bonzini 719f0bb276bSPaolo Bonzini static void x86_machine_set_max_ram_below_4g(Object *obj, Visitor *v, 720f0bb276bSPaolo Bonzini const char *name, void *opaque, 721f0bb276bSPaolo Bonzini Error **errp) 722f0bb276bSPaolo Bonzini { 723f0bb276bSPaolo Bonzini X86MachineState *x86ms = X86_MACHINE(obj); 724f0bb276bSPaolo Bonzini Error *error = NULL; 725f0bb276bSPaolo Bonzini uint64_t value; 726f0bb276bSPaolo Bonzini 727f0bb276bSPaolo Bonzini visit_type_size(v, name, &value, &error); 728f0bb276bSPaolo Bonzini if (error) { 729f0bb276bSPaolo Bonzini error_propagate(errp, error); 730f0bb276bSPaolo Bonzini return; 731f0bb276bSPaolo Bonzini } 732f0bb276bSPaolo Bonzini if (value > 4 * GiB) { 733f0bb276bSPaolo Bonzini error_setg(&error, 734f0bb276bSPaolo Bonzini "Machine option 'max-ram-below-4g=%"PRIu64 735f0bb276bSPaolo Bonzini "' expects size less than or equal to 4G", value); 736f0bb276bSPaolo Bonzini error_propagate(errp, error); 737f0bb276bSPaolo Bonzini return; 738f0bb276bSPaolo Bonzini } 739f0bb276bSPaolo Bonzini 740f0bb276bSPaolo Bonzini if (value < 1 * MiB) { 741f0bb276bSPaolo Bonzini warn_report("Only %" PRIu64 " bytes of RAM below the 4GiB boundary," 742f0bb276bSPaolo Bonzini "BIOS may not work with less than 1MiB", value); 743f0bb276bSPaolo Bonzini } 744f0bb276bSPaolo Bonzini 745f0bb276bSPaolo Bonzini x86ms->max_ram_below_4g = value; 746f0bb276bSPaolo Bonzini } 747f0bb276bSPaolo Bonzini 748f0bb276bSPaolo Bonzini static void x86_machine_initfn(Object *obj) 749f0bb276bSPaolo Bonzini { 750f0bb276bSPaolo Bonzini X86MachineState *x86ms = X86_MACHINE(obj); 751f0bb276bSPaolo Bonzini 752f0bb276bSPaolo Bonzini x86ms->max_ram_below_4g = 0; /* use default */ 753f0bb276bSPaolo Bonzini x86ms->smp_dies = 1; 754f0bb276bSPaolo Bonzini } 755f0bb276bSPaolo Bonzini 756f0bb276bSPaolo Bonzini static void x86_machine_class_init(ObjectClass *oc, void *data) 757f0bb276bSPaolo Bonzini { 758f0bb276bSPaolo Bonzini MachineClass *mc = MACHINE_CLASS(oc); 759f0bb276bSPaolo Bonzini X86MachineClass *x86mc = X86_MACHINE_CLASS(oc); 760f0bb276bSPaolo Bonzini NMIClass *nc = NMI_CLASS(oc); 761f0bb276bSPaolo Bonzini 762f0bb276bSPaolo Bonzini mc->cpu_index_to_instance_props = x86_cpu_index_to_props; 763f0bb276bSPaolo Bonzini mc->get_default_cpu_node_id = x86_get_default_cpu_node_id; 764f0bb276bSPaolo Bonzini mc->possible_cpu_arch_ids = x86_possible_cpu_arch_ids; 765f0bb276bSPaolo Bonzini x86mc->compat_apic_id_mode = false; 766*2f34ebf2SLiam Merwick x86mc->save_tsc_khz = true; 767f0bb276bSPaolo Bonzini nc->nmi_monitor_handler = x86_nmi; 768f0bb276bSPaolo Bonzini 769f0bb276bSPaolo Bonzini object_class_property_add(oc, X86_MACHINE_MAX_RAM_BELOW_4G, "size", 770f0bb276bSPaolo Bonzini x86_machine_get_max_ram_below_4g, x86_machine_set_max_ram_below_4g, 771f0bb276bSPaolo Bonzini NULL, NULL, &error_abort); 772f0bb276bSPaolo Bonzini 773f0bb276bSPaolo Bonzini object_class_property_set_description(oc, X86_MACHINE_MAX_RAM_BELOW_4G, 774f0bb276bSPaolo Bonzini "Maximum ram below the 4G boundary (32bit boundary)", &error_abort); 775f0bb276bSPaolo Bonzini } 776f0bb276bSPaolo Bonzini 777f0bb276bSPaolo Bonzini static const TypeInfo x86_machine_info = { 778f0bb276bSPaolo Bonzini .name = TYPE_X86_MACHINE, 779f0bb276bSPaolo Bonzini .parent = TYPE_MACHINE, 780f0bb276bSPaolo Bonzini .abstract = true, 781f0bb276bSPaolo Bonzini .instance_size = sizeof(X86MachineState), 782f0bb276bSPaolo Bonzini .instance_init = x86_machine_initfn, 783f0bb276bSPaolo Bonzini .class_size = sizeof(X86MachineClass), 784f0bb276bSPaolo Bonzini .class_init = x86_machine_class_init, 785f0bb276bSPaolo Bonzini .interfaces = (InterfaceInfo[]) { 786f0bb276bSPaolo Bonzini { TYPE_NMI }, 787f0bb276bSPaolo Bonzini { } 788f0bb276bSPaolo Bonzini }, 789f0bb276bSPaolo Bonzini }; 790f0bb276bSPaolo Bonzini 791f0bb276bSPaolo Bonzini static void x86_machine_register_types(void) 792f0bb276bSPaolo Bonzini { 793f0bb276bSPaolo Bonzini type_register_static(&x86_machine_info); 794f0bb276bSPaolo Bonzini } 795f0bb276bSPaolo Bonzini 796f0bb276bSPaolo Bonzini type_init(x86_machine_register_types) 797