Splitting out UEFI bootloader code from kernel

Now the bootloader should be responsible for all initial setup,
loading the kernel, and then handing off to the kernel with
proper data in place.

Makefile

@@ -20,7 +20,9 @@ DEPENDFLAGS    := -MMD
 
 INCLUDES       := -I $(ARCH_D)
 INCLUDES       += -I src/modules
-INCLUDES       += -isystem $(EFI_INCLUDES) -isystem $(EFI_INCLUDES)/$(ARCH) -isystem $(EFI_INCLUDES)/protocol
+INCLUDES       += -isystem $(EFI_INCLUDES)
+INCLUDES       += -isystem $(EFI_INCLUDES)/$(ARCH)
+INCLUDES       += -isystem $(EFI_INCLUDES)/protocol
 
 BASEFLAGS      := -O2 -fpic -nostdlib
 BASEFLAGS      += -ffreestanding -nodefaultlibs
@@ -30,35 +32,39 @@ ifdef CPU
 BASEFLAGS      += -mcpu=$(CPU)
 endif
 
-WARNFLAGS      := -Wall -Wextra -Wshadow -Wcast-align -Wwrite-strings
-WARNFLAGS      += -Winline -Wshadow
-WARNFLAGS      += -Wno-attributes -Wno-deprecated-declarations
-WARNFLAGS      += -Wno-div-by-zero -Wno-endif-labels -Wfloat-equal
-WARNFLAGS      += -Wformat=2 -Wno-format-extra-args -Winit-self
+# Removed Flags:: -Wcast-align
+WARNFLAGS      := -Wall -Werror -Wextra -Wshadow -Wwrite-strings
+WARNFLAGS      += -Wformat=2 -Winit-self -Wfloat-equal -Winline 
 WARNFLAGS      += -Winvalid-pch -Wmissing-format-attribute
-WARNFLAGS      += -Wmissing-include-dirs -Wno-multichar
-WARNFLAGS      += -Wno-sign-compare -Wswitch -Wundef
-WARNFLAGS      += -Wno-pragmas #-Wno-unused-but-set-parameter
-WARNFLAGS      += -Wno-unused-result #-Wno-unused-but-set-variable 
-WARNFLAGS      += -Wwrite-strings -Wdisabled-optimization -Wpointer-arith
-WARNFLAGS      += -Werror
+WARNFLAGS      += -Wmissing-include-dirs -Wswitch -Wundef
+WARNFLAGS      += -Wdisabled-optimization -Wpointer-arith
+
+WARNFLAGS      += -Wno-attributes -Wno-sign-compare -Wno-multichar
+WARNFLAGS      += -Wno-div-by-zero -Wno-endif-labels -Wno-pragmas
+WARNFLAGS      += -Wno-format-extra-args -Wno-unused-result
+WARNFLAGS      += -Wno-deprecated-declarations -Wno-unused-function
+WARNFLAGS      += -Wno-unused-but-set-parameter
 
 ASFLAGS        ?= 
 
-CFLAGS         ?= 
-CFLAGS         += $(INCLUDES) $(DEPENDFLAGS) $(BASEFLAGS) $(WARNFLAGS)
+CFLAGS         := $(INCLUDES) $(DEPENDFLAGS) $(BASEFLAGS) $(WARNFLAGS)
+CFLAGS         += -std=c11 -fpic -fshort-wchar
+CFLAGS         += -mno-red-zone -fno-stack-protector 
 CFLAGS         += -DGIT_VERSION="L\"$(VERSION)\""
-CFLAGS         += -std=c11 -fno-stack-protector -fpic -fshort-wchar -mno-red-zone
-CFLAGS         += -DEFI_DEBUG=0 -DEFI_DEBUG_CLEAR_MEMORY=0 -DGNU_EFI_USE_MS_ABI -DHAVE_USE_MS_ABI #-DEFI_FUNCTION_WRAPPER 
+CFLAGS         += -DEFI_DEBUG=0 -DEFI_DEBUG_CLEAR_MEMORY=0
+CFLAGS         += -DGNU_EFI_USE_MS_ABI -DHAVE_USE_MS_ABI
+#CFLAGS        += -DEFI_FUNCTION_WRAPPER 
 
+BOOT_CFLAGS	   := -I src/boot $(CFLAGS)
 ifdef MAX_HRES
-CFLAGS         += -DMAX_HRES=$(MAX_HRES)
+BOOT_CFLAGS    += -DMAX_HRES=$(MAX_HRES)
 endif
 
-LDFLAGS        ?= 
-LDFLAGS        += -L $(BUILD_D) -ggdb
-LDFLAGS        += -nostdlib -znocombreloc -shared -Bsymbolic -fPIC -nostartfiles 
-LDFLAGS        += -L $(EFI_ARCH_DIR)/lib -L $(EFI_ARCH_DIR)/gnuefi
+LDFLAGS        := -L $(BUILD_D) -ggdb -fPIC -shared
+LDFLAGS        += -nostdlib -znocombreloc -Bsymbolic -nostartfiles 
+
+BOOT_LDFLAGS   := $(LDFLAGS)
+BOOT_LDFLAGS   += -L $(EFI_ARCH_DIR)/lib -L $(EFI_ARCH_DIR)/gnuefi
 
 AS             ?= $(CROSS)as
 AR             ?= $(CROSS)ar
@@ -69,6 +75,11 @@ OBJC           := $(CROSS)objcopy
 OBJD           := $(CROSS)objdump
 
 INIT_DEP       := $(BUILD_D)/.builddir
+
+BOOT_SRCS      := $(wildcard src/boot/*.c)
+BOBJS          += $(patsubst src/boot/%,$(BUILD_D)/boot/%,$(patsubst %,%.o,$(BOOT_SRCS)))
+BDEPS          := $(patsubst src/boot/%,$(BUILD_D)/boot/%,$(patsubst %,%.d,$(BOOT_SRCS)))
+
 ARCH_SRCS      := $(wildcard $(ARCH_D)/*.s)
 ARCH_SRCS      += $(wildcard $(ARCH_D)/*.c)
 KOBJS          += $(patsubst $(ARCH_D)/%,$(BUILD_D)/arch/%,$(patsubst %,%.o,$(ARCH_SRCS)))
@@ -80,7 +91,13 @@ QEMU           ?= qemu-system-x86_64
 GDBPORT        ?= 27006
 CPUS           ?= 2
 OVMF           ?= assets/ovmf/x64/OVMF.fd 
-QEMUOPTS       := -bios $(OVMF) -hda $(BUILD_D)/fs.img -smp $(CPUS) -m 512 $(QEMUEXTRA) -d guest_errors
+
+QEMUOPTS       := -pflash $(OVMF)
+QEMUOPTS       += -drive file=$(BUILD_D)/fs.img,format=raw
+QEMUOPTS       += -smp $(CPUS)
+QEMUOPTS       += -m 512
+QEMUOPTS       += -d guest_errors
+QEMUOPTS       += $(QEMUEXTRA)
 
 
 all: $(BUILD_D)/fs.img
@@ -88,6 +105,7 @@ init: $(INIT_DEP)
 
 $(INIT_DEP):
 	mkdir -p $(BUILD_D) $(patsubst %,$(BUILD_D)/d.%,$(MODULES))
+	mkdir -p $(BUILD_D)/boot
 	mkdir -p $(BUILD_D)/arch
 	touch $(INIT_DEP)
 
@@ -108,32 +126,47 @@ $(BUILD_D)/.version:
 $(EFI_LIB):
 	make -C external/gnu-efi all
 
-$(BUILD_D)/kernel.elf: $(KOBJS) $(MOD_TARGETS) $(EFI_LIB)
-	$(LD) $(LDFLAGS) -T $(EFI_LDS) -o $@ \
-		$(EFI_CRT_OBJ) $(KOBJS) $(patsubst %,-l%,$(MODULES)) -lefi -lgnuefi
+$(BUILD_D)/kernel.elf: $(KOBJS) $(MOD_TARGETS) $(ARCH_D)/kernel.ld
+	$(LD) $(LDFLAGS) -T $(ARCH_D)/kernel.ld -o $@ $(KOBJS) $(patsubst %,-l%,$(MODULES))
 
-$(BUILD_D)/kernel.efi: $(BUILD_D)/kernel.elf
+$(BUILD_D)/boot.elf: $(BOBJS) $(EFI_LIB)
+	$(LD) $(BOOT_LDFLAGS) -T $(EFI_LDS) -o $@ \
+		$(EFI_CRT_OBJ) $(BOBJS) $(patsubst %,-l%,$(MODULES)) -lefi -lgnuefi
+
+$(BUILD_D)/boot.efi: $(BUILD_D)/boot.elf
 	objcopy -j .text -j .sdata -j .data -j .dynamic \
 	-j .dynsym  -j .rel -j .rela -j .reloc \
 	--target=efi-app-$(ARCH) $^ $@
 
-$(BUILD_D)/kernel.debug.efi: $(BUILD_D)/kernel.elf
+$(BUILD_D)/boot.debug.efi: $(BUILD_D)/boot.elf
 	objcopy -j .text -j .sdata -j .data -j .dynamic \
 	-j .dynsym  -j .rel -j .rela -j .reloc \
 	-j .debug_info -j .debug_abbrev -j .debug_loc -j .debug_str \
 	-j .debug_aranges -j .debug_line -j .debug_macinfo \
 	--target=efi-app-$(ARCH) $^ $@
 
-$(BUILD_D)/%.dump: $(BUILD_D)/%.efi
+$(BUILD_D)/%.elf.dump: $(BUILD_D)/%.elf
 	$(OBJD) -D -S $< > $@
 
+$(BUILD_D)/%.bin.dump: $(BUILD_D)/%.bin
+	$(OBJD) -D $< > $@
+
+$(BUILD_D)/%.bin: $(BUILD_D)/%.elf
+	$(OBJC) $< -O binary $@
+
+$(BUILD_D)/boot/%.s.o: src/boot/%.s $(INIT_DEP)
+	$(AS) $(ASFLAGS) -o $@ $<
+
+$(BUILD_D)/boot/%.c.o: src/boot/%.c $(INIT_DEP)
+	$(CC) $(BOOT_CFLAGS) -c -o $@ $<
+
 $(BUILD_D)/arch/%.s.o: $(ARCH_D)/%.s $(INIT_DEP)
 	$(AS) $(ASFLAGS) -o $@ $<
 
 $(BUILD_D)/arch/%.c.o: $(ARCH_D)/%.c $(INIT_DEP)
 	$(CC) $(CFLAGS) -c -o $@ $<
 
-$(BUILD_D)/fs.img: $(BUILD_D)/kernel.efi
+$(BUILD_D)/fs.img: $(BUILD_D)/boot.efi $(BUILD_D)/kernel.bin
 	$(eval TEMPFILE := $(shell mktemp --suffix=.img))
 	dd if=/dev/zero of=$@.tmp bs=512 count=93750
 	$(PARTED) $@.tmp -s -a minimal mklabel gpt
@@ -143,7 +176,9 @@ $(BUILD_D)/fs.img: $(BUILD_D)/kernel.efi
 	mformat -i $(TEMPFILE) -h 32 -t 32 -n 64 -c 1
 	mmd -i $(TEMPFILE) ::/EFI
 	mmd -i $(TEMPFILE) ::/EFI/BOOT
-	mcopy -i $(TEMPFILE) $^ ::/EFI/BOOT/BOOTX64.efi
+	mcopy -i $(TEMPFILE) $(BUILD_D)/boot.efi ::/EFI/BOOT/BOOTX64.efi
+	mcopy -i $(TEMPFILE) $(BUILD_D)/kernel.bin ::/kernel.bin
+	mlabel -i $(TEMPFILE) ::Popcorn_OS
 	dd if=$(TEMPFILE) of=$@.tmp bs=512 count=91669 seek=2048 conv=notrunc
 	rm $(TEMPFILE)
 	mv $@.tmp $@
@@ -159,7 +194,7 @@ qemu: $(BUILD_D)/fs.img
 qemu-window: $(BUILD_D)/fs.img
 	"$(QEMU)" $(QEMUOPTS)
 
-qemu-gdb: $(BUILD_D)/fs.img $(BUILD_D)/kernel.debug.efi
+qemu-gdb: $(BUILD_D)/fs.img $(BUILD_D)/boot.debug.efi
 	"$(QEMU)" $(QEMUOPTS) -S -D popcorn-qemu.log -s
 
 # vim: ft=make ts=4

src/arch/x86_64/boot.s

@@ -0,0 +1,12 @@
+; boot.s -- Kernel start location.
+
+[BITS 64]
+ALIGN 4
+
+SECTION .text
+[GLOBAL start]
+
+start:
+	; Load multiboot header location
+	mov ebx, 0xdeadbeef
+	jmp $

src/arch/x86_64/config.mk

@@ -1,5 +1,5 @@
 AS := nasm
-ASFLAGS := -felf
+ASFLAGS := -felf64
 LDFLAGS := -m elf_x86_64
 CFLAGS := -march=nocona -m64
 

src/arch/x86_64/kernel.ld

@@ -0,0 +1,26 @@
+ENTRY(start)
+SECTIONS
+{
+	. = 0x100000;
+
+	.text : {
+		code = .;
+		*(.text)
+		. = ALIGN(4096);
+	}
+
+	.data : {
+		 data = .;
+		 *(.data)
+		 *(.rodata)
+		 . = ALIGN(4096);
+	}
+
+	.bss : {
+		bss = .;
+		*(.bss)
+		. = ALIGN(4096);
+	}
+
+	end = .;
+}

src/boot/loader.c

@@ -0,0 +1,75 @@
+#include "loader.h"
+#include "utility.h"
+
+static CHAR16 kernel_name[] = KERNEL_FILENAME;
+
+static EFI_STATUS loader_load_file(EFI_FILE_PROTOCOL *root, void **kernel_image, UINT64 *len) {
+	EFI_STATUS status;
+
+	EFI_FILE_PROTOCOL *handle = 0;
+	status = root->Open(root, &handle, kernel_name, EFI_FILE_MODE_READ, 0);
+	CHECK_EFI_STATUS_OR_RETURN(status, "Failed to open kernel file handle");
+
+	EFI_FILE_INFO *info = LibFileInfo(handle);
+    if (info->FileSize == 0)
+        return EFI_NOT_FOUND;
+
+    UINTN count = ((info->FileSize - 1) / 0x1000) + 1;
+    EFI_PHYSICAL_ADDRESS addr = 0x100000; // Try to load the kernel in at 1MiB
+    EFI_MEMORY_TYPE memType = 0xFFFFFFFF;  // Special value to tell the kernel it's here
+    status = ST->BootServices->AllocatePages(AllocateAddress, memType, count, &addr);
+    if (status == EFI_NOT_FOUND) {
+        // couldn't get the address we wanted, try loading the kernel anywhere
+        status = ST->BootServices->AllocatePages(AllocateAnyPages, memType, count, &addr);
+    }
+	CHECK_EFI_STATUS_OR_RETURN(status, "Failed to allocate kernel pages");
+
+    UINTN buffer_size = count * 0x1000;
+    void *buffer = (void*)addr;
+    status = handle->Read(handle, &buffer_size, &buffer);
+	CHECK_EFI_STATUS_OR_RETURN(status, "Failed to read kernel to memory");
+
+	*len = buffer_size;
+	*kernel_image = buffer;
+	return EFI_SUCCESS;
+}
+
+EFI_STATUS loader_load_kernel(void **kernel_image, UINT64 *len) {
+    if (kernel_image == 0 || len == 0)
+        CHECK_EFI_STATUS_OR_RETURN(EFI_INVALID_PARAMETER, "NULL kernel_image pointer or size");
+
+	EFI_STATUS status;
+
+	// First, find all the handles that support the filesystem protocol. Call
+	UINTN size = 0;
+	EFI_GUID fs_guid = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID;
+	status = ST->BootServices->LocateHandle(ByProtocol, &fs_guid, NULL, &size, NULL);
+	if (status != EFI_BUFFER_TOO_SMALL) {
+		CHECK_EFI_STATUS_OR_RETURN(status, "Failed to find number of filesystem handles");
+	} else if (size == 0) {
+		CHECK_EFI_STATUS_OR_RETURN(EFI_NO_MEDIA, "Found zero filesystem handles");
+	}
+
+	EFI_HANDLE *buffer = 0;
+    status = ST->BootServices->AllocatePool(EfiLoaderData, size, (void**)&buffer);
+	CHECK_EFI_STATUS_OR_RETURN(status, "Failed to allocate buffer of filesystem handles");
+
+	status = ST->BootServices->LocateHandle(ByProtocol, &fs_guid, NULL, &size, buffer);
+	CHECK_EFI_STATUS_OR_RETURN(status, "Failed to find filesystem handles");
+
+	unsigned num_fs = size / sizeof(EFI_HANDLE);
+	EFI_HANDLE *fss = (EFI_HANDLE*)buffer;
+
+	for (unsigned i = 0; i < num_fs; ++i) {
+		EFI_FILE_HANDLE root = LibOpenRoot(fss[i]);
+
+		status = loader_load_file(root, kernel_image, len);
+        if (status == EFI_NOT_FOUND)
+            continue;
+
+		CHECK_EFI_STATUS_OR_RETURN(status, "Failed to load kernel");
+        return EFI_SUCCESS;
+	}
+
+    return EFI_NOT_FOUND;
+}

src/boot/loader.h

@@ -0,0 +1,8 @@
+#pragma once
+#include <efi.h>
+
+#ifndef KERNEL_FILENAME
+#define KERNEL_FILENAME L"kernel.bin"
+#endif
+
+EFI_STATUS loader_load_kernel(void **kernel_image, UINT64 *len);

src/boot/main.c

@@ -2,6 +2,7 @@
 #include <efilib.h>
 
 #include "console.h"
+#include "loader.h"
 #include "memory.h"
 #include "utility.h"
 
@@ -21,18 +22,31 @@ efi_main (EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
 	// be sure if the console was fully set up
 	status = con_initialize(GIT_VERSION);
 	CHECK_EFI_STATUS_OR_RETURN(status, "con_initialize");
-
 	// From here on out, use CHECK_EFI_STATUS_OR_FAIL instead
 	// because the console is now set up
 
-	/*
-	Print(L" SystemTable: %x\n", SystemTable);
-	if (SystemTable)
-		Print(L"	  ConOut: %x\n", SystemTable->ConOut);
-	if (SystemTable->ConOut)
-		Print(L"OutputString: %x\n", SystemTable->ConOut->OutputString);
-	*/
+	// Get info about the image
+	con_status_begin(L"Gathering image information...");
+	EFI_LOADED_IMAGE *info = 0;
+	EFI_GUID image_proto = EFI_LOADED_IMAGE_PROTOCOL_GUID;
+	status = ST->BootServices->HandleProtocol(ImageHandle, &image_proto, (void **)&info);
+    CHECK_EFI_STATUS_OR_FAIL(status);
+	con_status_ok();
 
+	con_status_begin(L"Virtualizing memory...");
+    status = memory_virtualize();
+    CHECK_EFI_STATUS_OR_FAIL(status);
+	con_status_ok();
+
+    con_status_begin(L"Loading kernel into memory...");
+    void *kernel_image = NULL;
+	UINT64 len = 0;
+    status = loader_load_kernel(&kernel_image, &len);
+    CHECK_EFI_STATUS_OR_FAIL(status);
+	Print(L" %u bytes at 0x%x", len, kernel_image);
+    con_status_ok();
+
+    /*
 	dump_memory_map();
 
 	UINTN memmap_size = 0;
@@ -54,6 +68,7 @@ efi_main (EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
 		memmap_size, desc_size, desc_version, memmap);
 	CHECK_EFI_STATUS_OR_FAIL(status);
 	con_status_ok();
+    */
 
 	while (1) __asm__("hlt");
 	return status;

src/boot/memory.c

@@ -24,18 +24,34 @@ const CHAR16 *memory_type_names[] = {
     L"EfiPersistentMemory",
 };
 
-const CHAR16 *memory_type_name(UINT32 value) {
+static const CHAR16 *memory_type_name(UINT32 value) {
     if (value >= (sizeof(memory_type_names)/sizeof(CHAR16*)))
         return L"Bad Type Value";
     return memory_type_names[value];
 }
 
-EFI_STATUS get_memory_map(EFI_MEMORY_DESCRIPTOR **buffer, UINTN *buffer_size,
+void EFIAPI memory_update_addresses(EFI_EVENT UNUSED *event, void UNUSED *context) {
+    ST->RuntimeServices->ConvertPointer(0, (void **)&BS);
+    ST->RuntimeServices->ConvertPointer(0, (void **)&ST);
+}
+
+EFI_STATUS memory_virtualize() {
+    EFI_STATUS status;
+    EFI_EVENT event;
+
+    status = ST->BootServices->CreateEvent(EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE,
+            TPL_CALLBACK, (EFI_EVENT_NOTIFY)&memory_update_addresses, NULL, &event);
+    CHECK_EFI_STATUS_OR_RETURN(status, "Failed to create memory update event");
+
+    return status;
+}
+
+EFI_STATUS memory_get_map(EFI_MEMORY_DESCRIPTOR **buffer, UINTN *buffer_size,
                           UINTN *key, UINTN *desc_size, UINT32 *desc_version) {
     EFI_STATUS status;
 
     UINTN needs_size = 0;
-    status = BS->GetMemoryMap(&needs_size, 0, key, desc_size, desc_version);
+    status = ST->BootServices->GetMemoryMap(&needs_size, 0, key, desc_size, desc_version);
     if (status != EFI_BUFFER_TOO_SMALL) {
         CHECK_EFI_STATUS_OR_RETURN(status, "Failed to load memory map");
     }
@@ -43,20 +59,20 @@ EFI_STATUS get_memory_map(EFI_MEMORY_DESCRIPTOR **buffer, UINTN *buffer_size,
     // Give some extra buffer to account for changes.
     *buffer_size = needs_size + 256;
     Print(L"Trying to load memory map with size %d.\n", *buffer_size);
-    status = BS->AllocatePool(EfiLoaderData, *buffer_size, (void**)buffer);
+    status = ST->BootServices->AllocatePool(EfiLoaderData, *buffer_size, (void**)buffer);
     CHECK_EFI_STATUS_OR_RETURN(status, "Failed to allocate space for memory map");
 
-    status = BS->GetMemoryMap(buffer_size, *buffer, key, desc_size, desc_version);
+    status = ST->BootServices->GetMemoryMap(buffer_size, *buffer, key, desc_size, desc_version);
     CHECK_EFI_STATUS_OR_RETURN(status, "Failed to load memory map");
     return EFI_SUCCESS;
 }
 
-EFI_STATUS dump_memory_map() {
+EFI_STATUS memory_dump_map() {
     EFI_MEMORY_DESCRIPTOR *buffer;
     UINTN buffer_size, desc_size, key;
     UINT32 desc_version;
 
-    EFI_STATUS status = get_memory_map(&buffer, &buffer_size, &key,
+    EFI_STATUS status = memory_get_map(&buffer, &buffer_size, &key,
         &desc_size, &desc_version);
     CHECK_EFI_STATUS_OR_RETURN(status, "Failed to get memory map");
 
@@ -79,6 +95,6 @@ EFI_STATUS dump_memory_map() {
         d = (EFI_MEMORY_DESCRIPTOR *)((uint8_t *)d + desc_size);
     }
 
-    BS->FreePool(buffer);
+    ST->BootServices->FreePool(buffer);
     return EFI_SUCCESS;
 }

src/boot/memory.h

@@ -1,13 +1,13 @@
 #pragma once
 #include <efi.h>
 
-const CHAR16 *memory_type_name(UINT32 value);
+EFI_STATUS memory_virtualize();
 
-EFI_STATUS get_memory_map(
+EFI_STATUS memory_get_map(
     EFI_MEMORY_DESCRIPTOR **buffer,
     UINTN *buffer_size,
     UINTN *key,
     UINTN *desc_size,
     UINT32 *desc_version);
 
-EFI_STATUS dump_memory_map();
+EFI_STATUS memory_dump_map();

src/boot/utility.h

@@ -2,6 +2,8 @@
 #include <efilib.h>
 #include "console.h"
 
+#define UNUSED __attribute__((unused))
+
 const CHAR16 *util_error_message(EFI_STATUS status);
 
 #define CHECK_EFI_STATUS_OR_RETURN(s, msg, ...)   \