| Filename | Latest commit message | Latest commit date |
|---|---|---|
879db62379
The BIOS loader handed the kernel a 32-bit entry that climbed into long mode itself; the UEFI loader arrived already there and used a separate 64-bit entry. Two entries meant two copies of the same preconditions, and that is not a hypothetical cost -- it is exactly where EFER.SCE went missing for months, set on one path and not the other, invisible until a program tried to return from a syscall. stage2 does the climb now. It builds the page tables where the UEFI loader builds them and meaning the same thing -- 4 GB identity-mapped with 1 GB pages, and the same 4 GB again at 0xffff800000000000, because entry64low's first instruction is a movabs to a high address and identity alone triple faults on it -- sets PAE, LME and SCE, enables paging, and far jumps through a GDT with an L-bit code descriptor, which a 32-bit descriptor cannot express. stage2main.c is compiled for x86_64 and runs in long mode. It still reads the multiboot header to find where the kernel's segments go, but enters through the SCH64 header rather than the entry named there: that entry is 32-bit code whose only job is the climb, and dropping back to 32 bits to redo work already done is a mode switch for no reason. If the SCH64 header is absent it halts, because there is no longer anything to fall back to. So both loaders now hand over identically -- long mode, interrupts off, CR3 mapping the low 4 GB twice, framebuffer in RBX -- and there is one set of preconditions instead of two that can drift. Verified on every path that exists: BIOS to schinit; BIOS with -smp 2, which brings up cpu1 through the AP trampoline's own separate climb; the resolution menu still selecting 1024x768 over serial; the ISO, which loads through ATAPI and a ramdisk root; UEFI unchanged at 1018 MB in 7 regions; bootcheck 108 [ok]. stage2 is 21988 of 24576 bytes. The 32-bit mboot_entry stays in entry.S. Nothing of ours uses it now, but it is what makes the kernel loadable by a multiboot loader that is not ours, and removing it is a separate decision from this one. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
| .. | ||
| bios | ||
| uefi | ||
| README.md | ||
Booting SchOS
Two firmware paths, kept apart on purpose:
boot/
bios/ legacy BIOS: MBR, El Torito CD stub, real-mode stage 2
uefi/ UEFI application (not written yet)
They are separate directories rather than #ifdefs in one because they share
almost nothing. A BIOS loader lives in 16-bit real mode, talks to the firmware
through software interrupts, and has to walk itself up into long mode. A UEFI
loader is a 64-bit PE executable that the firmware has already placed in long
mode with paging on, and it asks for services by calling through a table of
function pointers. The only things genuinely in common are the logo bitmap, the
menu's appearance, and the hand-off contract below.
What the loader must hand the kernel
Whichever path runs, the kernel expects the same things. This is the contract; a second loader is correct exactly when it satisfies it.
| Where | Notes | |
|---|---|---|
| Kernel image | loaded per its ELF program headers | entry at entry64 |
| CPU state | see below -- the two paths differ here | |
| Memory map | E820_MAP_ADDR, 24-byte entries, count at E820_COUNT_ADDR |
kernel/arch/x86_64/e820.c reads it |
| Framebuffer | VBE_INFO_ADDR |
address, pitch, width, height, depth |
| Verbose flag | BOOT_VERBOSE_FLAG_ADDR |
set by the F8 menu |
The addresses are defined once, in include/memlayout.h and
boot/bios/stage2main.c. A UEFI loader must fill the same structures — the
kernel does not care which firmware produced them, and that is what keeps the
split cheap.
Two entry points, because the two firmwares hand over differently
The BIOS path enters the kernel in 32-bit protected mode at the multiboot
entry, with EAX holding the framebuffer address; mboot_entry then builds page
tables and climbs into long mode itself.
UEFI hands a loader long mode with paging already on. Dropping back to
protected mode only to climb out again is a mode switch whose failure mode is a
triple fault with no console, so the kernel publishes a second entry instead.
kernel/arch/x86_64/entry.S carries a sch64_header — magic SCH64BOO,
8-byte aligned within the first 16 KB, followed by a 64-bit physical address —
found by scanning, exactly as the BIOS loader scans for the multiboot magic.
include/schboot.h holds the magic so loader and kernel cannot disagree.
What that entry expects:
- long mode, interrupts off
- CR3 pointing at tables that identity-map the low 4 GB and map the same
4 GB at
0xffff800000000000.entry64low's first instruction is amovabsto a high address, so identity alone triple faults immediately. - RBX = the framebuffer physical address, and never 1 — that value marks an
application processor in
entry64high.
The kernel loads its own GDT at that entry (entry64uefi), rather than the
loader doing it. A loader arriving in long mode is still on the firmware's
descriptors, and the first thing the kernel does that depends on its own
selectors takes a #GP against a GDT the firmware no longer owns — it
surfaced as unexpected trap 13 ... cs=38, a long way from the cause.
e820.c reads a BIOS memory map. UEFI hands out a different structure
(EFI_MEMORY_DESCRIPTOR, from GetMemoryMap), so the UEFI loader has to
translate it into the same 24-byte entries rather than inventing a second
format for the kernel to learn.
The BIOS path today
bios/bootasm.S— the literal MBR sector. Signed to 512 bytes bytools/sign.pl, loads stage 2 from LBA 1 and jumps.bios/cdboot.S— the same job for optical media, as an El Torito no-emulation image. Separate because the loader never uses INT 13h and so needs a real ATAPI read.bios/stage2.S— collects the E820 map, sets a VBE mode, enters protected mode.bios/stage2main.c— the boot menu and splash, then loads the kernel and enters long mode.
STAGE2_SECTORS is defined once, in the Makefile, and passed to both the
assembler and the dd that writes the image. It used to be written out by hand
in five places and silently truncated the loader when they disagreed.
Why UEFI is worth doing
Everything since roughly 2012 boots UEFI by default, and Secure Boot machines will not run the BIOS path at all without firmware settings most people never touch. The BIOS loader stays regardless: it is what QEMU's default machine and older hardware use, and it costs nothing to keep once the two are separated.