bool_t
x86_cpuid_initialize(void)
{
cpu_identity_t *ci = x86_cpuid_get_identity();
struct family_model original;
cpuid_001h_eax_t eax;
cpuid_001h_ebx_t ebx;
memset(ci, 0, sizeof(*ci));
/* First determine which vendor manufactured the CPU. */
x86_cpuid_fill_vendor_string(ci);
/* Need both eax and ebx ouput values. */
eax.words[0] = x86_cpuid_eax(1, 0);
ebx.words[0] = x86_cpuid_ebx(1, 0);
/* We now use EAX for the family, model, stepping values, and EBX for the
* brand index. Store the original values from CPUID_001H.EAX.
*/
original.family = cpuid_001h_eax_get_family(eax);
original.model = cpuid_001h_eax_get_model(eax);
ci->display.stepping = cpuid_001h_eax_get_stepping(eax);
/* Also store extended family and model values used for adjustment */
ci->display.extended_family = cpuid_001h_eax_get_extended_family(eax);
ci->display.extended_model = cpuid_001h_eax_get_extended_model(eax);
/* Also store the brand index value given in EBX */
ci->display.brand = cpuid_001h_ebx_get_brand(ebx);
if (strncmp(ci->vendor_string, X86_CPUID_VENDOR_STRING_INTEL,
X86_CPUID_VENDOR_STRING_MAXLENGTH) == 0) {
ci->vendor = X86_VENDOR_INTEL;
x86_cpuid_intel_identity_initialize(ci, original);
return true;
} else if (strncmp(ci->vendor_string, X86_CPUID_VENDOR_STRING_AMD_LEGACY,
X86_CPUID_VENDOR_STRING_MAXLENGTH) == 0
|| strncmp(ci->vendor_string, X86_CPUID_VENDOR_STRING_AMD,
X86_CPUID_VENDOR_STRING_MAXLENGTH) == 0) {
ci->vendor = X86_VENDOR_AMD;
x86_cpuid_amd_identity_initialize(ci, original);
return true;
} else {
/* CPU from unsupported vendor. Examples could be Cyrix, Centaur, etc.
* The old time x86 clones. Return false to the boot and let the upper
* level caller decide what to do.
*/
ci->vendor = X86_VENDOR_OTHER;
return false;
}
}
static BOOT_CODE bool_t
try_boot_sys(
unsigned long multiboot_magic,
multiboot_info_t* mbi
)
{
/* ==== following code corresponds to the "select" in abstract specification ==== */
acpi_rsdt_t* acpi_rsdt; /* physical address of ACPI root */
paddr_t mods_end_paddr; /* physical address where boot modules end */
paddr_t load_paddr;
word_t i;
p_region_t ui_p_regs;
multiboot_module_t *modules = (multiboot_module_t*)(word_t)mbi->mod_list;
if (multiboot_magic != MULTIBOOT_MAGIC) {
printf("Boot loader not multiboot compliant\n");
return false;
}
cmdline_parse((const char *)(word_t)mbi->cmdline, &cmdline_opt);
if ((mbi->flags & MULTIBOOT_INFO_MEM_FLAG) == 0) {
printf("Boot loader did not provide information about physical memory size\n");
return false;
}
if (!x86_cpuid_initialize()) {
printf("Warning: Your x86 CPU has an unsupported vendor, '%s'.\n"
"\tYour setup may not be able to competently run seL4 as "
"intended.\n"
"\tCurrently supported x86 vendors are AMD and Intel.\n",
x86_cpuid_get_identity()->vendor_string);
}
if (!is_compiled_for_microarchitecture()) {
printf("Warning: Your kernel was not compiled for the current microarchitecture.\n");
}
#if CONFIG_MAX_NUM_NODES > 1
/* copy boot code for APs to lower memory to run in real mode */
if (!copy_boot_code_aps(mbi->mem_lower)) {
return false;
}
/* Initialize any kernel TLS */
mode_init_tls(0);
#endif
/* initialize the memory. We track two kinds of memory regions. Physical memory
* that we will use for the kernel, and physical memory regions that we must
* not give to the user. Memory regions that must not be given to the user
* include all the physical memory in the kernel window, but also includes any
* important or kernel devices. */
boot_state.mem_p_regs.count = 0;
init_allocated_p_regions();
if (mbi->flags & MULTIBOOT_INFO_MMAP_FLAG) {
if (!parse_mem_map(mbi->mmap_length, mbi->mmap_addr)) {
return false;
}
} else {
/* calculate memory the old way */
p_region_t avail;
avail.start = HIGHMEM_PADDR;
avail.end = ROUND_DOWN(avail.start + (mbi->mem_upper << 10), PAGE_BITS);
if (!add_mem_p_regs(avail)) {
return false;
}
}
boot_state.ki_p_reg.start = PADDR_LOAD;
boot_state.ki_p_reg.end = kpptr_to_paddr(ki_end);
/* copy VESA information from multiboot header */
if ((mbi->flags & MULTIBOOT_INFO_GRAPHICS_FLAG) == 0) {
boot_state.vbe_info.vbeMode = -1;
printf("Multiboot gave us no video information\n");
} else {
boot_state.vbe_info.vbeInfoBlock = *(seL4_VBEInfoBlock_t*)(seL4_Word)mbi->vbe_control_info;
boot_state.vbe_info.vbeModeInfoBlock = *(seL4_VBEModeInfoBlock_t*)(seL4_Word)mbi->vbe_mode_info;
boot_state.vbe_info.vbeMode = mbi->vbe_mode;
printf("Got VBE info in multiboot. Current video mode is %d\n", mbi->vbe_mode);
boot_state.vbe_info.vbeInterfaceSeg = mbi->vbe_interface_seg;
boot_state.vbe_info.vbeInterfaceOff = mbi->vbe_interface_off;
boot_state.vbe_info.vbeInterfaceLen = mbi->vbe_interface_len;
}
printf("Kernel loaded to: start=0x%lx end=0x%lx size=0x%lx entry=0x%lx\n",
boot_state.ki_p_reg.start,
boot_state.ki_p_reg.end,
boot_state.ki_p_reg.end - boot_state.ki_p_reg.start,
(paddr_t)_start
);
/* remapping legacy IRQs to their correct vectors */
pic_remap_irqs(IRQ_INT_OFFSET);
if (config_set(CONFIG_IRQ_IOAPIC)) {
/* Disable the PIC so that it does not generate any interrupts. We need to
* do this *before* we initialize the apic */
pic_disable();
}
/* get ACPI root table */
acpi_rsdt = acpi_init();
if (!acpi_rsdt) {
return false;
}
/* check if kernel configuration matches platform requirments */
if (!acpi_fadt_scan(acpi_rsdt)) {
return false;
}
if (!config_set(CONFIG_IOMMU) || cmdline_opt.disable_iommu) {
boot_state.num_drhu = 0;
} else {
/* query available IOMMUs from ACPI */
acpi_dmar_scan(
acpi_rsdt,
boot_state.drhu_list,
&boot_state.num_drhu,
MAX_NUM_DRHU,
&boot_state.rmrr_list
);
}
/* query available CPUs from ACPI */
boot_state.num_cpus = acpi_madt_scan(acpi_rsdt, boot_state.cpus, &boot_state.num_ioapic, boot_state.ioapic_paddr);
if (boot_state.num_cpus == 0) {
printf("No CPUs detected\n");
return false;
}
if (config_set(CONFIG_IRQ_IOAPIC)) {
if (boot_state.num_ioapic == 0) {
printf("No IOAPICs detected\n");
return false;
}
} else {
if (boot_state.num_ioapic > 0) {
printf("Detected %d IOAPICs, but configured to use PIC instead\n", boot_state.num_ioapic);
}
}
if (!(mbi->flags & MULTIBOOT_INFO_MODS_FLAG)) {
printf("Boot loader did not provide information about boot modules\n");
return false;
}
printf("Detected %d boot module(s):\n", mbi->mod_count);
if (mbi->mod_count < 1) {
printf("Expect at least one boot module (containing a userland image)\n");
return false;
}
mods_end_paddr = 0;
for (i = 0; i < mbi->mod_count; i++) {
printf(
" module #%ld: start=0x%x end=0x%x size=0x%x name='%s'\n",
i,
modules[i].start,
modules[i].end,
modules[i].end - modules[i].start,
(char *) (long)modules[i].name
);
if ((sword_t)(modules[i].end - modules[i].start) <= 0) {
printf("Invalid boot module size! Possible cause: boot module file not found by QEMU\n");
return false;
}
if (mods_end_paddr < modules[i].end) {
mods_end_paddr = modules[i].end;
}
}
mods_end_paddr = ROUND_UP(mods_end_paddr, PAGE_BITS);
assert(mods_end_paddr > boot_state.ki_p_reg.end);
printf("ELF-loading userland images from boot modules:\n");
load_paddr = mods_end_paddr;
load_paddr = load_boot_module(modules, load_paddr);
if (!load_paddr) {
return false;
}
/* calculate final location of userland images */
ui_p_regs.start = boot_state.ki_p_reg.end;
ui_p_regs.end = ui_p_regs.start + load_paddr - mods_end_paddr;
printf(
"Moving loaded userland images to final location: from=0x%lx to=0x%lx size=0x%lx\n",
mods_end_paddr,
ui_p_regs.start,
ui_p_regs.end - ui_p_regs.start
);
memcpy((void*)ui_p_regs.start, (void*)mods_end_paddr, ui_p_regs.end - ui_p_regs.start);
/* adjust p_reg and pv_offset to final load address */
boot_state.ui_info.p_reg.start -= mods_end_paddr - ui_p_regs.start;
boot_state.ui_info.p_reg.end -= mods_end_paddr - ui_p_regs.start;
boot_state.ui_info.pv_offset -= mods_end_paddr - ui_p_regs.start;
/* ==== following code corresponds to abstract specification after "select" ==== */
if (!platAddDevices()) {
return false;
}
/* Total number of cores we intend to boot */
ksNumCPUs = boot_state.num_cpus;
printf("Starting node #0 with APIC ID %lu\n", boot_state.cpus[0]);
if (!try_boot_sys_node(boot_state.cpus[0])) {
return false;
}
if (config_set(CONFIG_IRQ_IOAPIC)) {
ioapic_init(1, boot_state.cpus, boot_state.num_ioapic);
}
/* initialize BKL before booting up APs */
SMP_COND_STATEMENT(clh_lock_init());
SMP_COND_STATEMENT(start_boot_aps());
/* grab BKL before leaving the kernel */
NODE_LOCK_SYS;
printf("Booting all finished, dropped to user space\n");
return true;
}
