HELLO: Include EfiLoaderCode and EfiLoaderData memory regions in memory map

Unfortunately, crashes... :(

.bochsrc

@@ -1,43 +0,0 @@
-# configuration file generated by Bochs
-config_interface: textconfig
-display_library: x
-megs: 32
-romimage: file=/usr/share/bochs/BIOS-bochs-latest, address=0xf0000
-vgaromimage: /usr/share/bochs/VGABIOS-lgpl-latest
-boot: floppy
-floppya: 1_44="hos.flp", status=inserted
-# no floppyb
-ata0: enabled=1, ioaddr1=0x1f0, ioaddr2=0x3f0, irq=14
-ata1: enabled=0
-ata2: enabled=0
-ata3: enabled=0
-parport1: enabled=1, file=""
-com1: enabled=1, dev=""
-usb1: enabled=1, ioaddr=0xff80, irq=10
-# no sb16
-floppy_bootsig_check: disabled=0
-vga_update_interval: 30000
-keyboard_serial_delay: 20000
-keyboard_paste_delay: 100000
-floppy_command_delay: 50000
-ips: 500000
-text_snapshot_check: 0
-mouse: enabled=0
-private_colormap: enabled=0
-i440fxsupport: enabled=0
-clock: sync=none, time0=local
-# no ne2k
-newharddrivesupport: enabled=1
-# no loader
-log: -
-logprefix: %t%e%d
-debugger_log: -
-panic: action=ask
-error: action=report
-info: action=report
-debug: action=ignore
-pass: action=fatal
-keyboard_mapping: enabled=0, map=
-keyboard_type: mf
-user_shortcut: keys=none
-# no cmosimage

.gitignore

@@ -0,0 +1,3 @@
+.rscons*
+/x86_64-elf-gcc/
+/build/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "uefi-d"]
+	path = uefi-d
+	url = git://github.com/kubasz/uefi-d

Makefile

@@ -1,48 +0,0 @@
-# Makefile for HOS
-# Josh Holtrop
-# Created: 07/09/04
-
-FLOPPY=/dev/fd0
-FLOPPY_MOUNT=./mnt_flp
-FLOPPY_IMAGE=hos.flp
-GRUB_IMAGE=grub.flp
-
-all:
-	make -C kernel
-#	make -C rmmod
-
-clean:
-	make -C kernel clean
-	make -C include clean
-#	make -C rmmod clean
-	- rm *~ hos.flp
-
-
-grub:
-	- mkdir $(FLOPPY_MOUNT)
-	mke2fs $(FLOPPY)
-	mount -t ext2 $(FLOPPY) $(FLOPPY_MOUNT)
-	grub-install --root-directory=$(FLOPPY_MOUNT) fd0
-	umount $(FLOPPY_MOUNT)
-	- rmdir $(FLOPPY_MOUNT)
-
-grub_image:
-	dd if=$(FLOPPY) of=$(GRUB_IMAGE)
-
-install:
-	- mkdir $(FLOPPY_MOUNT)
-	mount -t ext2 $(FLOPPY) $(FLOPPY_MOUNT)
-	cp kernel/kernel.bin  $(FLOPPY_MOUNT)
-	cp menu.lst $(FLOPPY_MOUNT)/boot/grub
-	umount $(FLOPPY_MOUNT)
-	- rmdir $(FLOPPY_MOUNT)
-
-install_img:
-	- mkdir $(FLOPPY_MOUNT)
-	cp grub.flp $(FLOPPY_IMAGE)
-	mount -t ext2 -o loop $(FLOPPY_IMAGE) $(FLOPPY_MOUNT)
-	cp kernel/kernel.bin $(FLOPPY_MOUNT)
-	cp menu.lst $(FLOPPY_MOUNT)/boot/grub
-	umount $(FLOPPY_MOUNT)
-	- rmdir $(FLOPPY_MOUNT)
-

Rsconscript

@@ -0,0 +1,113 @@
+require "tmpdir"
+
+project_name "HOS"
+path_prepend "x86_64-elf-gcc/bin"
+
+configure do
+  rscons "x86_64-elf-gcc.rb", "-b", "#{build_dir}/x86_64-elf-gcc"
+  check_d_compiler "ldc2", use: "ldc2"
+  check_c_compiler "x86_64-w64-mingw32-gcc", use: "x86_64-w64-mingw32-gcc"
+  check_c_compiler "x86_64-elf-gcc", use: "x86_64-elf-gcc"
+  check_c_compiler
+  check_program "mformat", on_fail: "Install the mtools package"
+  check_cfg package: "freetype2", on_fail: "Install libfreetype-dev", use: "freetype"
+  sh %w[git submodule update --init]
+end
+
+# Kernel default font size.
+KFONT_SIZE = 15
+
+class HulkBinObj < Builder
+  def run(options)
+    File.write(@target, <<EOF)
+.section ".rodata"
+.balign 4096
+.global hulk_start
+hulk_start:
+.incbin "#{@sources.first}"
+.balign 4096
+.global hulk_end
+hulk_end:
+EOF
+    unless @cache.up_to_date?(@target, nil, @sources, @env)
+      print_run_message("Creating HULK binary object <target>#{@target}<reset>", nil)
+      @cache.register_build(@target, nil, @sources, @env)
+    end
+    true
+  end
+end
+
+class Image < Builder
+  def run(options)
+    unless @cache.up_to_date?(@target, nil, @sources, @env)
+      print_run_message("Creating disk image <target>#{@target}<reset>", nil)
+      File.binwrite(@target, "\0" * (1440 * 1024))
+      system(*%W[mformat -i #{@target} -f 1440 ::])
+      system(*%W[mmd -i #{@target} ::/EFI])
+      system(*%W[mmd -i #{@target} ::/EFI/BOOT])
+      system(*%W[mcopy -i #{@target} #{@sources.first} ::/EFI/BOOT])
+      @cache.register_build(@target, nil, @sources, @env)
+    end
+    true
+  end
+end
+
+class FontGen < Builder
+  def run(options)
+    if @command
+      finalize_command
+    else
+      fontgen = @vars["fontgen"]
+      @sources += [fontgen]
+      command = %W[#{fontgen} #{@sources.first} #{KFONT_SIZE} #{@target}]
+      standard_command("FontGen <target>#{@target}<reset>", command, {})
+    end
+  end
+end
+
+fontgen_env = env "fontgen", use: "freetype" do |env|
+  env.Program("^/fontgen", glob("src/fontgen/**/*.c"))
+end
+
+hulk_env = env "hulk", use: %w[ldc2 x86_64-elf-gcc] do |env|
+  env["sources"] = glob("src/hulk/**/*.d")
+  env["DFLAGS"] += %w[-mtriple=x86_64-unknown-elf --betterC -release -O3 --wi --enable-cross-module-inlining]
+  env["D_IMPORT_PATH"] += %w[src/hulk src/common]
+  env["LD"] = "x86_64-elf-gcc"
+  env["LDFLAGS"] += %w[-nostdlib -Tsrc/hulk/hulk.ld -Wl,-Map,${_TARGET}.map]
+  env["LDCMD"] = %w[${LD} -o ${_TARGET} ${LDFLAGS} ${_SOURCES} ${LIBDIRPREFIX}${LIBPATH} ${LIBLINKPREFIX}${LIBS}]
+  env["OBJDUMP"] = "x86_64-elf-objdump"
+  env["OBJCOPY"] = "x86_64-elf-objcopy"
+  env.Program("^/hulk.elf", "${sources}")
+  env.depends("^/hulk.elf", "src/hulk/hulk.ld")
+  env.Disassemble("^/hulk.txt", "^/hulk.elf")
+  env.Command("^/hulk.bin", "^/hulk.elf",
+              "CMD" => %W[${OBJCOPY} -O binary ${_SOURCES} ${_TARGET}],
+              "CMD_DESC" => "Convert ELF to binary:")
+end
+
+hello_env = env "hello", use: %w[ldc2 x86_64-w64-mingw32-gcc] do |env|
+  env.add_builder(Image)
+  env.add_builder(HulkBinObj)
+  env["sources"] = glob("src/hello/**/*.d")
+  env["sources"] += glob("uefi-d/source/**/*.d")
+  env.HulkBinObj("^/hulk_bin.S", hulk_env.expand("^/hulk.bin"))
+  env["sources"] << "^/hulk_bin.S"
+  env["DFLAGS"] += %w[-mtriple=x86_64-unknown-windows-coff --betterC -release -O3 --wi --enable-cross-module-inlining]
+  env["D_IMPORT_PATH"] += %w[src/hello src/hulk uefi-d/source src/common]
+  env["LD"] = "x86_64-w64-mingw32-gcc"
+  env["LDFLAGS"] += %w[-nostdlib -Wl,-dll -shared -Wl,--subsystem,10 -e efi_main -Wl,-Map,${_TARGET}.map]
+  env["LDCMD"] = %w[${LD} -o ${_TARGET} ${LDFLAGS} ${_SOURCES} ${LIBDIRPREFIX}${LIBPATH} ${LIBLINKPREFIX}${LIBS}]
+  env["OBJDUMP"] = "x86_64-w64-mingw32-objdump"
+  env.Program("^/BOOTX64.EFI", "${sources}")
+  env.Disassemble("^/BOOTX64.txt", "^/BOOTX64.EFI")
+  env.Image("^/hos.img", "^/BOOTX64.EFI")
+end
+
+task "run", desc: "Run HOS in QEMU" do
+  Dir.mktmpdir do |tmpdir|
+    img = hello_env.expand("^/hos.img")
+    FileUtils.cp(img, tmpdir)
+    sh %W[qemu-system-x86_64 -bios OVMF.fd -drive file=#{tmpdir}/hos.img,format=raw]
+  end
+end

include/Makefile

@@ -1,2 +0,0 @@
-clean:
-	- rm *~

include/kernel.h

@@ -1,23 +0,0 @@
-
-#ifndef __HOS_KERNEL_H__
-#define __HOS_KERNEL_H__ __HOS_KERNEL_H__
-
-#include "multiboot.h"
-
-#define VIRT_OFFSET 0xC0000000
-#define MAX_MODULES 16
-#define MAX_MMAP 16
-
-typedef unsigned int u32_t;
-typedef unsigned short u16_t;
-typedef unsigned char u8_t;
-
-/* returns true to callee if we should jump to a real mode module */
-int k_mbsave(mb_info_t *mbinfo, unsigned int mb_magic);
-
-void k_init();
-
-void isr();
-
-#endif
-

include/module.h

@@ -1,16 +0,0 @@
-
-#ifndef __HOS_MODULE_H__
-#define __HOS_MODULE_H__ __HOS_MODULE_H__
-
-#define MOD_REAL_MODE 1
-#define MOD_KERNEL 2
-
-typedef struct {
-	unsigned int mod_magic;		// "HOSM" = 0x484F534D
-	unsigned int mod_type;		// module type
-	void (*init) ();		// address of void initialization function
-	unsigned int reserved;
-} hos_module_header_t;
-
-#endif
-

include/multiboot.h

@@ -1,144 +0,0 @@
-
-#ifndef __HOS_MULTIBOOT_H__
-#define __HOS_MULTIBOOT_H__ __HOS_MULTIBOOT_H__
-
-/* The magic number for the Multiboot header. */
-#define MULTIBOOT_HEADER_MAGIC          0x1BADB002
-
-#define MB_HEADER_ALIGN_MODULES 0x01
-#define MB_HEADER_MEM_INFO 0x02
-#define MB_HEADER_VIDEO_INFO 0x04
-#define MB_HEADER_KLUDGE_OFFSETS 0x10000
-
-
-/* The magic number passed by a Multiboot-compliant boot loader. */
-#define MULTIBOOT_BOOTLOADER_MAGIC      0x2BADB002
-
-#define MB_BOOTLOADER_MEM_INFO 0x01
-#define MB_BOOTLOADER_BOOT_DEVICE 0x02
-#define MB_BOOTLOADER_COMMAND_LINE 0x04
-#define MB_BOOTLOADER_MODS 0x08
-#define MB_BOOTLOADER_AOUT 0x10
-#define MB_BOOTLOADER_ELF 0x20
-#define MB_BOOTLOADER_MMAP 0x40
-#define MB_BOOTLOADER_DRIVES 0x80
-#define MB_BOOTLOADER_CONFIG 0x0100
-#define MB_BOOTLOADER_APM 0x0200
-#define MB_BOOTLOADER_GRAPHICS 0x0400
-
-
-#define MB_DRIVE_MODE_CHS 0
-#define MB_DRIVE_MODE_LBA 1
-
-
-/* The Multiboot header. */
-typedef struct
-{
-	unsigned int magic;
-	unsigned int flags;
-	unsigned int checksum;
-	unsigned int header_addr;
-	unsigned int load_addr;
-	unsigned int load_end_addr;
-	unsigned int bss_end_addr;
-	unsigned int entry_addr;
-} mb_header_t;
-
-/* The symbol table for a.out. */
-typedef struct
-{
-	unsigned int tabsize;
-	unsigned int strsize;
-	unsigned int addr;
-	unsigned int reserved;
-} mb_aout_symbol_table_t;
-
-/* The section header table for ELF. */
-typedef struct
-{
-	unsigned int num;
-	unsigned int size;
-	unsigned int addr;
-	unsigned int shndx;
-} mb_elf_section_header_table_t;
-
-/* The Multiboot information. */
-typedef struct
-{
-	unsigned int flags;
-	unsigned int mem_lower;		// present if flags[0] is set
-	unsigned int mem_upper;
-	unsigned int boot_device;	// 1
-	unsigned int cmdline;		// 2
-	unsigned int mods_count;	// 3
-	unsigned int mods_addr;
-	union
-	{
-		mb_aout_symbol_table_t aout_sym;	// 4
-		mb_elf_section_header_table_t elf_sec;	// 5
-	};
-	unsigned int mmap_length;	// 6
-	unsigned int mmap_addr;
-	unsigned int drives_length;	// 7
-	unsigned int drives_addr;
-	unsigned int config_table;	// 8
-	unsigned int bootloader_name;	// 9
-	unsigned int apm_table;		// 10
-
-	unsigned int vbe_control_info;	// 11
-	unsigned int vbe_mode_info;
-	unsigned short vbe_mode;
-	unsigned short vbe_interface_seg;
-	unsigned short vbe_interface_off;
-	unsigned short vbe_interface_len;
-} mb_info_t;
-
-/* The module structure. */
-typedef struct
-{
-	unsigned int mod_start;
-	unsigned int mod_end;
-	unsigned int string;
-	unsigned int reserved;
-} mb_module_t;
-
-/* The memory map. Be careful that the offset 0 is base_addr_low, not size. */
-typedef struct
-{
-	unsigned int size;		//offset -4
-	unsigned int base_addr_low;	//offset 0
-	unsigned int base_addr_high;
-	unsigned int length_low;
-	unsigned int length_high;
-	unsigned int type;
-} mb_mmap_t;
-
-/* The drive structure */
-typedef struct
-{
-	unsigned int size;
-	unsigned char drive_number;
-	unsigned char drive_mode;
-	unsigned char drive_cylinders;
-	unsigned char drive_heads;
-	unsigned char drive_sectors;
-	unsigned short drive_ports[1];
-} mb_drive_t;
-
-/* APM table structure */
-typedef struct
-{
-	unsigned short version;
-	unsigned short cseg;
-	unsigned int offset;
-	unsigned short cseg_16;
-	unsigned short dseg;
-	unsigned short flags;
-	unsigned short cseg_len;
-	unsigned short cseg_16_len;
-	unsigned short dseg_len;
-} mb_apm_t;
-
-
-#endif
-

kernel/Makefile

@@ -1,33 +0,0 @@
-# Makefile for HOS
-# Josh Holtrop
-# Created: 07/08/04
-# Modified: 07/09/04
-
-# Assembler Information:
-NASM=nasm
-NASM_FLAGS=-f aout
-
-# C Information:
-CC=gcc
-CC_FLAGS=-fleading-underscore -fno-builtin -nostdlib -nostartfiles -nodefaultlibs -I. -I../include -Wall
-
-# Linker Information:
-LD=ld
-LD_FLAGS=-nodefaultlibs -nostdlib --no-demangle -T link.ld
-
-all: Asm_Kernel C_Kernel
-	$(LD) $(LD_FLAGS) -Map boot.map boot.o kernel.o -o kernel.bin
-
-Asm_Kernel:
-	$(NASM) $(NASM_FLAGS) -l boot.lst boot.asm -o boot.o
-
-C_Kernel:
-	$(CC) $(CC_FLAGS) -c kernel.c -o kernel.o
-
-#################################################
-# Clean up the source directory of any binaries #
-#################################################
-clean:
-	- rm *.s *.S *.o *.bin *~ *.map *.lst
-
-

kernel/boot.asm

@@ -1,196 +0,0 @@
-;boot.asm
-;Author: Josh Holtrop
-;Date: 07/08/04
-;Modified: 07/10/04
-
-
-%define	MULTIBOOT_MAGIC	0x1BADB002
-%define	MULTIBOOT_FLAGS	0x00010003
-
-%define VIRT_OFFSET	0xC0000000	;3gb virtual address
-%define PHYS_START	0x00100000	;1mb physical address
-%define VIRT_STACK_TOP	0xCFFFFFFC	;3gb+256mb virtual address
-%define GDT_P	PHYS_START		;1mb physical - Global Descriptor Table space
-%define GDT_V	GDT_P+VIRT_OFFSET
-%define IDT_P	PHYS_START+0x2000	;1mb+8kb - Interrupt Descriptor Table space
-%define IDT_V	IDT_P+VIRT_OFFSET
-%define PDBR_P	PHYS_START+0x4000	;1mb+16kb - Page Directory Base Register (first PD)
-%define PDBR_V	PDBR_P+VIRT_OFFSET
-%define LOPT_P	PHYS_START+0x5000	;1mb+20kb - LOw Page Table for mapping first 4mb
-%define LOPT_V	LOPT_P+VIRT_OFFSET
-%define PT_STACK_P PHYS_START+0x6000	;1mb+24kb - page table for initial kernel stack pages (under 0xD0000000)
-%define PT_STACK_V PT_STACK_P+VIRT_OFFSET
-%define STACK_P	PHYS_START+0x7000	;1mb+28kb - initial 4kb kernel stack page
-%define STACK_V	STACK_P+VIRT_OFFSET
-%define KERNEL_P PHYS_START+0x8000	;1mb+32kb - the kernel's physical address
-%define KERNEL_V KERNEL_P+VIRT_OFFSET	;3gb+1mb+32kb, the virtual address of the kernel
-
-extern _k_init, _isr, _k_mbsave, _end
-
-[bits 32]
-
-[global _start]
-_start:
-
-multiboot_header:
-	dd	MULTIBOOT_MAGIC					;magic
-	dd	MULTIBOOT_FLAGS					;flags
-	dd	-(MULTIBOOT_MAGIC + MULTIBOOT_FLAGS)		;checksum
-
-	dd	multiboot_header-VIRT_OFFSET			;header_addr
-	dd	_start-VIRT_OFFSET				;load_addr
-	dd	0						;load_end_addr
-	dd	_end-VIRT_OFFSET				;bss_end_addr
-	dd	multiboot_entry-VIRT_OFFSET			;entry_addr
-
-;	dd	1						;mode_type
-;	dd	80						;width
-;	dd	25						;height
-;	dd	0						;depth
-
-[global multiboot_entry]
-multiboot_entry:
-;This is where the kernel begins execution from the bootloader.
-;At this point, a temporary gdt is set up to "map" 0xC000_0000 to 0x0.
-	cli					;should already be off...
-	lgdt	[gdtrbs32-VIRT_OFFSET]
-	jmp	KERNEL_CODE_BS32:segmented_start
-segmented_start:
-	mov	ax, KERNEL_DATA_BS32
-	mov	ss, ax
-	mov	ds, ax
-	mov	es, ax
-	mov	gs, ax
-	mov	fs, ax
-	mov	esp, STACK_V+0x1000		;ok, now we can access our data
-
-;aloop:
-;	inc dword [0xC00B8000]
-;	jmp	aloop
-
-
-;Then the multiboot info structures are saved to local data variables.
-	add	ebx, VIRT_OFFSET
-	push	eax
-	push	ebx				;pointer to multiboot info structure
-	call	_k_mbsave			;save multiboot info structures
-	add	esp, 8
-
-	cmp	eax, 0
-	jz	pm_return
-
-;go back to real mode to initialize video mode
-	mov	ebx, pm_return
-
-
-
-;Next we enable paging with the first 4mb mapped 1:1 virtual:physical
-; and with the 4mb starting at 0xC000_0000 mapped to the first 4mb physical.
-pm_return:
-	xor	eax, eax
-	mov	edi, PDBR_V
-	mov	ecx, 1024			;clear the PDBR
-	rep stosd
-	mov	edi, PT_STACK_V
-	mov	ecx, 1024			;clear the PT_STACK
-	rep stosd
-	mov	[PDBR_V], dword LOPT_P|0x03		;store the physical address of the LOw Page Table | (read/write, present)
-	mov	[PDBR_V+0xC00], dword LOPT_P|0x03	;store the physical address of the LOw Page Table | (read/write, present)
-	mov	[PDBR_V+0xCFC], dword PT_STACK_P|0x03	;store the physical address of the initial stack page page table | (read/write, present)
-	mov	[PT_STACK_V+0xFFC], dword STACK_P|0x03	;store the physical address of the initial stack page | (read/write, present)
-
-	mov	edi, LOPT_V
-	mov	ecx, 1024
-	mov	eax, 0x03			;starting physical address = 0x0 | (read/write, present flags)
-fill_lopt_loop:					;fill the page table
-	stosd
-	add	eax, 4096			;increment next phsyical address by 4kb
-	loop	fill_lopt_loop
-
-	mov	eax, PDBR_P
-	mov	cr3, eax			;store the Page Directory Base Address
-	mov	eax, cr0
-	or	eax, 0x80000000			;set Page Enable bit
-	mov	cr0, eax			;now paging is active!
-
-
-	mov	edi, GDT_V
-	mov	esi, gdt
-	mov	ecx, gdt_end-gdt
-	rep movsb
-
-	mov	edi, IDT_V		;destination
-	mov	esi, isr_0		;address of isr0
-	mov	edx, isr_1-isr_0	;distance between isr labels
-	mov	ecx, 50			;number of isrlabels
-fill_idt:
-	mov	ebx, esi
-	mov	ax, si
-	stosw				;0 offset 15:0
-	mov	ax, KERNEL_CODE
-	stosw				;2 selector 15:0
-	mov	ax, 0x8E00
-	stosw				;4 [P][DPL][0][TYPE][0][0][0][0][0][0][0][0]
-	shr	esi, 16
-	mov	ax, si
-	stosw				;6 offset 31:16
-	mov	esi, ebx
-	add	esi, edx
-	loop	fill_idt
-	mov	word	[IDT_V+0x30*8+4], 0xEE00	;interrupt 0x30 has user priviledges
-
-;Then we can start using our "real" gdt, then unmap the lower 4mb.
-	lgdt	[gdtr]			;load gdt
-	jmp	KERNEL_CODE:newgdtcontinue
-newgdtcontinue:
-	mov	ax, KERNEL_DATA
-	mov	es, ax
-	mov	ds, ax
-	mov	gs, ax
-	mov	fs, ax
-	mov	ss, ax
-	mov	esp, VIRT_STACK_TOP		;stack just under 3gb+256mb, moves downward
-	lidt	[idtr]				;load idt
-	mov	[PDBR_V], dword 0		;unmap 0x0, we are running completely paged at 0xC000_0000
-
-	call	_k_init			;C kernel initialization
-
-idle_loop:
-;	sti
-	hlt
-	jmp	idle_loop
-
-;-------------------------------------------------------
-gdtrbs32:
-	dw	gdt_endbs32-gdtbs32-1
-	dd	gdtbs32-VIRT_OFFSET
-gdtbs32:				;null descriptor
-	dd	0
-	dd	0
-
-	;a base of 0x4000_0000, when added to 0xC000_0000 will produce 0x0000_0000 physical before paging in effect
-KERNEL_CODE_BS32 equ $-gdtbs32
-	db	0xff		;limit	7:0
-	db	0xff		;limit	15:8
-	db	0x00		;base	7:0
-	db	0x00		;base	15:8
-	db	0x00		;base	23:16
-	db	0x9a		;access
-	db	0xcf		;flags / limit 19:16
-	db	0x40		;base	31:24
-
-KERNEL_DATA_BS32 equ $-gdtbs32
-	db	0xff		;limit	7:0
-	db	0xff		;limit	15:8
-	db	0x00		;base	7:0
-	db	0x00		;base	15:8
-	db	0x00		;base	23:16
-	db	0x92		;access
-	db	0xcf		;flags / limit 19:16
-	db	0x40		;base	31:24
-
-gdt_endbs32:
-
-%include "gdt.inc"
-%include "idt.inc"
-

kernel/gdt.inc

@@ -1,71 +0,0 @@
-;gdt.inc
-;Author: Josh Holtrop
-;Date: 10/30/03
-;Modified: 03/02/04
-
-gdtr:
-	dw	gdt_end-gdt-1
-	dd	GDT_V
-gdt:
-	dd	0
-	dd	0
-KERNEL_CODE equ $-gdt
-	dw	0xffff	;limit 15:0
-	dw	0x0000	;base  15:0
-	db	0x00	;base  23:16
-	db	0x9A	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
-	db	0xCF	;flags ([G][D/B][0][0]) / limit 19:16
-	db	0x00	;base  31:24
-KERNEL_DATA equ $-gdt
-	dw	0xffff	;limit 15:0
-	dw	0x0000	;base  15:0
-	db	0x00	;base  23:16
-	db	0x92	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
-	db	0xCF	;flags ([G][D/B][0][0]) / limit 19:16
-	db	0x00	;base  31:24
-USER_CODE equ $-gdt
-	dw	0xffff	;limit 15:0
-	dw	0x0000	;base  15:0
-	db	0x00	;base  23:16
-	db	0xFA	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
-	db	0xCF	;flags ([G][D/B][0][0]) / limit 19:16
-	db	0x00	;base  31:24
-USER_DATA equ $-gdt
-	dw	0xffff	;limit 15:0
-	dw	0x0000	;base  15:0
-	db	0x00	;base  23:16
-	db	0xF2	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
-	db	0xCF	;flags ([G][D/B][0][0]) / limit 19:16
-	db	0x00	;base  31:24
-VESA_CODE equ $-gdt
-	dw	0xffff	;limit 15:0
-	dw	0x0000	;base  15:0
-	db	0x00	;base  23:16
-	db	0x9A	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
-	db	0x40	;flags ([G][D/B][0][0]) / limit 19:16
-	db	0x00	;base  31:24
-VESA_DATA equ $-gdt
-	dw	0xffff	;limit 15:0
-	dw	0x0000	;base  15:0
-	db	0x00	;base  23:16
-	db	0x92	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
-	db	0x40	;flags ([G][D/B][0][0]) / limit 19:16
-	db	0x00	;base  31:24
-VIDEO_TEXT equ $-gdt
-	dw	0x7FFF	;limit 15:0
-	dw	0x8000	;base  15:0
-	db	0x0B	;base  23:16
-	db	0x92	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
-	db	0x40	;flags ([G][D/B][0][0]) / limit 19:16
-	db	0x00	;base  31:24
-VIDEO_GRAPHICS equ $-gdt
-	dw	0xFFFF	;limit 15:0
-	dw	0x0000	;base  15:0
-	db	0x0A	;base  23:16
-	db	0x92	;access ([P][DPL][1][Executable][Direction/Conforming][Writable/Readable][A])
-	db	0x40	;flags ([G][D/B][0][0]) / limit 19:16
-	db	0x00	;base  31:24
-gdt_end:
-
-
-

kernel/idt.inc

@@ -1,92 +0,0 @@
-;idt.inc
-;Author: Josh Holtrop
-;Date: 10/30/03
-;Modified: 07/06/04
-
-idtr:
-	dw	50*8-1		;size of idt
-	dd	IDT_V		;address of idt
-
-
-%macro isr_label 1
-isr_%1:
-	push	eax
-	mov	eax, %1
-	jmp	isr_main
-%endmacro
-
-isr_label	0
-isr_label	1
-isr_label	2
-isr_label	3
-isr_label	4
-isr_label	5
-isr_label	6
-isr_label	7
-isr_label	8
-isr_label	9
-isr_label	10
-isr_label	11
-isr_label	12
-isr_label	13
-isr_label	14
-isr_label	15
-isr_label	16
-isr_label	17
-isr_label	18
-isr_label	19
-isr_label	20
-isr_label	21
-isr_label	22
-isr_label	23
-isr_label	24
-isr_label	25
-isr_label	26
-isr_label	27
-isr_label	28
-isr_label	29
-isr_label	30
-isr_label	31
-isr_label	32
-isr_label	33
-isr_label	34
-isr_label	35
-isr_label	36
-isr_label	37
-isr_label	38
-isr_label	39
-isr_label	40
-isr_label	41
-isr_label	42
-isr_label	43
-isr_label	44
-isr_label	45
-isr_label	46
-isr_label	47
-isr_label	48
-isr_label	49
-
-isr_main:
-	pusha
-	push	ds
-	push	es
-
-	push	eax	;interrupt number
-	call	_isr
-	add	esp, 4
-
-	pop	es
-	pop	ds
-	popa
-	pop	eax		;original saved eax
-
-	iret
-
-
-
-
-
-
-
-
-

kernel/kernel.c

@@ -1,76 +0,0 @@
-
-#include "kernel.h"
-#include "multiboot.h"
-#include "module.h"
-
-mb_info_t mb_info_block;
-mb_mmap_t mb_mmap[MAX_MMAP];
-mb_module_t mb_modules[MAX_MODULES];
-mb_apm_t mb_apm_table;
-char mb_cmdline[256];
-
-/* This function runs in segmented memory - 0xC000_0000 is mapped to 0x0 but 0x0
-   itself is an invalid linear address. Therefore, the multiboot information addresses
-   must be manually adjusted by VIRT_OFFSET to become valid linear addresses. */
-int k_mbsave(mb_info_t *mbinfo, unsigned int mb_magic)
-{
-	if (mb_magic != MULTIBOOT_BOOTLOADER_MAGIC)
-	{
-		char *msg = "Bad multiboot magic identifier!";
-		char *dest = (char *) 0xC00B8000;
-		while (*msg)
-		{
-			*dest++ = *msg++;
-			*dest++ = 0x04;		//red error message
-		}
-		for (;;) ;
-	}
-	mb_info_block = *mbinfo;
-	if (mb_info_block.flags & MB_BOOTLOADER_COMMAND_LINE)
-	{
-		mb_info_block.cmdline += VIRT_OFFSET;
-		memcpy(mb_cmdline, mb_info_block.cmdline, 256);
-		mb_cmdline[255] = 0;
-	}
-	if (mb_info_block.flags & MB_BOOTLOADER_MODS)
-	{
-		mb_info_block.mods_addr += VIRT_OFFSET;
-		int i;
-		for (i = 0; i < mb_info_block.mods_count && i < MAX_MODULES; i++)
-		{
-			mb_modules[i] = ((mb_module_t *)mb_info_block.mods_addr)[i];
-		}
-	}
-	if (mb_info_block.flags & MB_BOOTLOADER_MMAP)
-	{
-		mb_info_block.mmap_addr += VIRT_OFFSET - 4;	//-4 to get to size field, not base_addr_low field
-		mb_mmap_t *mmap = (mb_mmap_t *)mb_info_block.mmap_addr;
-		int i, sz = 0;
-		for (i = 0; sz < mb_info_block.mmap_length && i < MAX_MMAP; i++)
-		{
-			sz += mmap->size;
-			mb_mmap[i] = *mmap;
-			mmap = (mb_mmap_t *)(((u32_t) mmap) + mmap->size);
-		}
-	}
-	if (mb_info_block.flags & MB_BOOTLOADER_APM)
-	{
-		mb_info_block.apm_table += VIRT_OFFSET;
-		mb_apm_table = *(mb_apm_t *)mb_info_block.apm_table;
-	}
-	return 0;
-}
-
-void k_init()
-{
-	for (;;)
-	{
-		(*(char*)0xC00B8000)++;
-	}
-}
-
-void isr()
-{
-	for (;;) ;
-}
-

kernel/link.ld

@@ -1,26 +0,0 @@
-OUTPUT_FORMAT("binary")
-ENTRY(_start)
-SECTIONS
-{
-  .text  0xC0108000 : {
-    code = .; _code = .; __code = .;
-    *(.text)
-    . = ALIGN(4096);
-  }
-  .data  : {
-    data = .; _data = .; __data = .;
-    *(.data)
-/*    . = ALIGN(4096); */
-  }
-  .rodata  : {
-    rodata = .; _rodata = .; __rodata = .;
-    *(.rodata)
-    . = ALIGN(4096);
-  }
-  .bss  : {
-    bss = .; _bss = .; __bss = .;
-    *(.bss)
-    . = ALIGN(4096);
-  }
-  end = .; _end = .; __end = .;
-}

menu.lst

@@ -1,9 +0,0 @@
-
-timeout 10
-default 0
-
-title HOS 0.15
-root (fd0)
-kernel /kernel.bin
-
-

readme.txt

@@ -0,0 +1,89 @@
+HOS - Holtrop's Operating System
+--------------------------------
+
+HOS is (in the process of becoming) a 32-bit, protected mode, graphical, multitasking operating system.
+It was written by me, Josh Holtrop, with help from a few others along the way.
+
+
+Goals: (A = accomplished, P = in progress, T = todo)
+----------------------------------------------------
+(A) Custom bootloader to load kernel from FAT-formatted boot media, options for video mode/ram disk
+(A) Multiboot compliance - kernel can be loaded by GRUB
+(A) 32-bit protected mode environment
+(A) VESA Support for graphics modes
+(A) PS/2 keyboard & mouse drivers
+(A) Utilize x86's paging architecture for virtual memory management
+
+(P) Console Manager
+(P) VFS abstraction layer for a single file system
+(P) ram disk driver
+(P) devfs file system driver
+(P) ext2 file system support
+
+(T) vfat file system support
+(T) Multitasking support
+(T) HASH command shell
+(T) Window Manager
+(T) Various other utilities/applications
+(T) Hard Drive (ATA) driver
+(T) cdrom (ATAPI) driver
+
+
+Change Log
+----------
+0.16
+12/16/04 - initrd going to be loaded as a gzipped ext2 image (kernel module) - faster loading!
+
+0.15
+07/10/04 - Multiboot support added, loadable by GRUB
+
+0.14
+05/21/04 - C++ support in kernel, can use classes & templates
+04/04/04 - video_line function for diagonal lines
+03/16/04 - new VFS design with support for a loop device
+03/01/04 - Thanks to Ben Meyer for helping me get a Makefile working and building on linux to work!
+
+0.13
+01/26/04 - functions added to read/write CMOS clock date and time
+01/19/04 - fixed bug GDTR/IDTR pointing to physical rather than linear table base address
+01/07/04 - fixed bug not reading sectors correctly from floppy
+12/28/03 - fixed bug not storing eax on interrupt
+12/25/03 - fixed bug in mm_palloc()
+12/25/03 - incorporated output functions as regular functions rather than as part of a linked library
+12/23/03 - re-written physical memory manager using bitmap instead of stack
+12/22/03 - kernel relocated to 3gb linear / 1mb+24kb physical to allow for app. address space
+
+0.12
+12/21/03 - sample bmp loader tested, works (tests loading a kernel of size ~ 932kb)
+12/20/03 - GDT/IDT now located at 1mb physical, before kernel
+10/30/03 - turns floppy motor off
+10/30/03 - keyboard LEDs working
+10/29/03 - paging functions working
+10/15/03 - physical memory management page allocators working
+
+0.11
+10/09/03 - PS/2 mouse driver
+
+0.10
+09/11/03 - Rewritten C and assembly kernel with VESA GUI mode support, keyboard driver
+
+0.05
+05/14/03 - HGUI24/HGUI32 commands finished for testing GUI on both 24bpp and 32bpp graphics cards
+05/14/03 - first web release!
+
+0.04
+03/09/03 - added VM shortcut command
+03/09/03 - press up to fill retrieve last inputted command for Nate Scholten
+03/08/03 - press clear to clear console input
+03/07/03 - added "shortcut" commands PC, IC, ? for Nate Scholten
+03/06/03 - added PROMPTC, INPUTC commands
+
+0.03
+12/30/02 - Command Line Interface working, accepting basic commands
+
+0.02
+12/11/02 - Assembly bootsector can load stage2 ("console")
+
+0.01
+12/01/02 - Real mode assembly bootsector boots from floppy disk successfully
+

rscons

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+# Copyright (c) 2013-2022 Josh Holtrop
+#
+# MIT License
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+script = File.join(File.dirname(__FILE__), ".rscons-3.0.2-c49c635f1e4166223367979510498b28.rb")
+unless File.exists?(script)
+  if File.read(__FILE__, mode: "rb") =~ /^#==>(.*)/
+    require "zlib"
+    require "base64"
+    encoded_compressed = $1
+    unescaped_compressed = Base64.decode64(encoded_compressed)
+    inflated = Zlib::Inflate.inflate(unescaped_compressed)
+    File.open(script, "wb") do |fh|
+      fh.write(inflated)
+    end
+  else
+    raise "Could not decompress."
+  end
+end
+load script
+if __FILE__ == $0
+  Rscons::Cli.new.run(ARGV)
+end
+#==>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 truncated

src-old/boot.S

@@ -0,0 +1,18 @@
+.global hos_start
+.type hos_start, @function
+hos_start:
+    /* Set stack pointer. */
+    mov $_stack_end, %esp
+ 
+    /* Jump to C. */
+    push $0
+    push $0
+    push $0
+    push %ebx
+    call hos_main
+ 
+    cli
+1:  hlt
+    jmp 1b
+ 
+.size hos_start, . - hos_start

src-old/fb.c

@@ -0,0 +1,116 @@
+#include "fb.h"
+#include <stddef.h>
+#include "mem.h"
+
+static struct {
+    uint32_t * addr;
+    uint32_t width;
+    uint32_t height;
+    uint32_t pitch;
+} fb;
+
+static inline uint32_t build_pixel(uint8_t r, uint8_t g, uint8_t b)
+{
+    return (r << 16u) | (g << 8u) | b;
+}
+
+static inline void fb_set_pixel(int x, int y, uint8_t r, uint8_t g, uint8_t b)
+{
+    fb.addr[fb.pitch * y + x] = build_pixel(r, g, b);
+}
+
+void fb_clear(void)
+{
+    memset32(fb.addr, 0u, fb.pitch * fb.height);
+}
+
+void fb_init(uint32_t * addr, uint32_t width, uint32_t height, uint32_t pitch)
+{
+    fb.addr = addr;
+    fb.width = width;
+    fb.height = height;
+    fb.pitch = pitch / 4u;
+    fb_clear();
+}
+
+uint32_t * fb_addr(void)
+{
+    return fb.addr;
+}
+
+bool fb_ready(void)
+{
+    return fb.addr != NULL;
+}
+
+uint32_t fb_width(void)
+{
+    return fb.width;
+}
+
+uint32_t fb_height(void)
+{
+    return fb.height;
+}
+
+void fb_blend_alpha8(const uint8_t * bitmap, int width, int height, int pitch, int x, int y, uint8_t r, uint8_t g, uint8_t b)
+{
+    if (((x + width) <= 0) || (x >= (int)fb.width) || ((y + height) <= 0) || (y >= (int)fb.height))
+    {
+        return;
+    }
+    if (x < 0)
+    {
+        width += x;
+        bitmap += (-x);
+        x = 0;
+    }
+    if (y < 0)
+    {
+        height += y;
+        bitmap += ((-y) * pitch);
+        y = 0;
+    }
+    if ((x + width) > (int)fb.width)
+    {
+        width = (int)fb.width - x;
+    }
+    if ((y + height) > (int)fb.height)
+    {
+        height = (int)fb.height - y;
+    }
+    uint32_t * target = &fb.addr[fb.pitch * y + x];
+    for (int row = 0; row < height; row++)
+    {
+        for (int col = 0; col < width; col++)
+        {
+            uint32_t alpha = bitmap[col];
+            uint32_t current_pixel = target[col];
+            uint8_t cr = (current_pixel >> 16u) & 0xFFu;
+            uint8_t cg = (current_pixel >> 8u) & 0xFFu;
+            uint8_t cb = current_pixel & 0xFFu;
+            uint8_t pr = alpha * r / 255u;
+            uint8_t pg = alpha * g / 255u;
+            uint8_t pb = alpha * b / 255u;
+            uint32_t current_alpha = 255u - alpha;
+            uint32_t pixel = build_pixel(
+                    pr + current_alpha * cr / 255u,
+                    pg + current_alpha * cg / 255u,
+                    pb + current_alpha * cb / 255u);
+            target[col] = pixel;
+        }
+        bitmap += pitch;
+        target += fb.pitch;
+    }
+}
+
+void fb_fill(int x, int y, int width, int height, uint8_t r, uint8_t g, uint8_t b)
+{
+    uint32_t * target = &fb.addr[fb.pitch * y + x];
+    uint32_t pixel = build_pixel(r, g, b);
+    for (int row = 0; row < height; row++)
+    {
+        memset32(target, pixel, width);
+        target += fb.pitch;
+    }
+}

src-old/fb.h

@@ -0,0 +1,16 @@
+#ifndef FB_H
+#define FB_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+void fb_init(uint32_t * addr, uint32_t width, uint32_t height, uint32_t pitch);
+bool fb_ready(void);
+uint32_t * fb_addr(void);
+uint32_t fb_width(void);
+uint32_t fb_height(void);
+void fb_blend_alpha8(const uint8_t * bitmap, int width, int height, int pitch, int x, int y, uint8_t r, uint8_t g, uint8_t b);
+void fb_fill(int x, int y, int width, int height, uint8_t r, uint8_t g, uint8_t b);
+void fb_clear(void);
+
+#endif

src-old/fb_text.c

@@ -0,0 +1,11 @@
+#include "fb_text.h"
+#include "kfont.h"
+#include "fb.h"
+
+void fb_text_render_char(int c, int x, int y, uint8_t r, uint8_t g, uint8_t b)
+{
+    const fontgen_char_info_t * char_info = kfont.char_infos[c];
+    y += kfont.line_height - kfont.baseline_offset - char_info->top;
+    x += char_info->left;
+    fb_blend_alpha8(char_info->bitmap, char_info->width, char_info->height, char_info->width, x, y, r, g, b);
+}

src-old/fb_text.h

@@ -0,0 +1,8 @@
+#ifndef FB_TEXT_H
+#define FB_TEXT_H
+
+#include <stdint.h>
+
+void fb_text_render_char(int c, int x, int y, uint8_t r, uint8_t g, uint8_t b);
+
+#endif

src-old/gdt.S

@@ -0,0 +1,16 @@
+.global gdt_set
+.extern gdtr
+.type gdt_set, @function
+gdt_set:
+    lgdt gdtr
+    jmp $0x8, $gdt_set_reload
+gdt_set_reload:
+    mov $0x10, %ax
+    mov %ax, %ds
+    mov %ax, %es
+    mov %ax, %fs
+    mov %ax, %gs
+    mov %ax, %ss
+    ret
+
+.size gdt_set, . - gdt_set

src-old/gdt.c

@@ -0,0 +1,20 @@
+#include "gdt.h"
+
+static const gdt_entry_t gdt_entries[] = {
+    /* Null descriptor */
+    0u,
+    /* Code segment for kernel */
+    gdt_build_entry(0u, 0xFFFFFu, 1u, 0u, 1u, 1u, 0u, 1u, 0u, 1u, 1u, 0u),
+    /* Data segment for kernel */
+    gdt_build_entry(0u, 0xFFFFFu, 1u, 0u, 1u, 0u, 0u, 1u, 0u, 1u, 1u, 0u),
+};
+
+gdtr_t gdtr;
+
+void gdt_init(void)
+{
+    gdtr.size = sizeof(gdt_entries);
+    gdtr.offset_lower = (uintptr_t)gdt_entries & 0xFFFFu;
+    gdtr.offset_upper = (uintptr_t)gdt_entries >> 16u;
+    gdt_set();
+}

src-old/gdt.h

@@ -0,0 +1,34 @@
+#ifndef GDT_H
+#define GDT_H
+
+#include <stdint.h>
+
+typedef struct {
+    uint16_t size;
+    uint16_t offset_lower;
+    uint16_t offset_upper;
+    uint16_t _reserved;
+} gdtr_t;
+
+typedef uint64_t gdt_entry_t;
+#define gdt_build_entry(base, limit, pr, privl, s, ex, dc, rw, ac, gr, sz, l) \
+    (gdt_entry_t)( \
+            (((gdt_entry_t)base << 32) & 0xFF00000000000000ull) | /* Base 0:15 */ \
+            (((gdt_entry_t)gr & 0x1u) << 55) | /* Granularity (0 = bytes, 1 = blocks) */ \
+            (((gdt_entry_t)sz & 0x1u) << 54) | /* Size (0 = 16-bit, 1 = 32-bit) */ \
+            (((gdt_entry_t)l & 0x1u) << 53) | /* L flag (x86_64 code) */ \
+            (((gdt_entry_t)limit << 32) & 0x000F000000000000ull) | /* Limit 16:19 */ \
+            (((gdt_entry_t)pr & 0x1u) << 47) | /* Present flag */ \
+            (((gdt_entry_t)privl & 0x3u) << 45) | /* Privilege (ring level) */ \
+            (((gdt_entry_t)s & 0x1u) << 44) | /* Type (0 = system, 1 = code/data) */ \
+            (((gdt_entry_t)ex & 0x1u) << 43) | /* Executable flag */ \
+            (((gdt_entry_t)dc & 0x1u) << 42) | /* Direction/Conforming */ \
+            (((gdt_entry_t)rw & 0x1u) << 41) | /* Readable/Writable */ \
+            (((gdt_entry_t)ac & 0x1u) << 40) | /* Accessed flag */ \
+            (((gdt_entry_t)base << 16) & 0x000000FFFFFF0000ull) | /* Base 0:23 */ \
+             ((gdt_entry_t)limit & 0x000000000000FFFFull)) /* Limit 0:15 */
+
+void gdt_init(void);
+void gdt_set(void);
+
+#endif

src-old/hos_main.c

@@ -0,0 +1,25 @@
+#include <stdint.h>
+#include "fb.h"
+#include "mbinfo.h"
+#include "klog.h"
+#include "gdt.h"
+#include "mm.h"
+
+void hos_main(uint32_t mbinfo_addr)
+{
+    gdt_init();
+    if (!mbinfo_init(mbinfo_addr))
+    {
+        return;
+    }
+    if (!fb_ready())
+    {
+        return;
+    }
+    klog_init();
+    klog_printf("Welcome to HOS!\n");
+    mm_init();
+    mbinfo_load();
+    klog_printf("Found %dKB of usable RAM\n", mm_get_total_ram() / 1024u);
+    klog_printf("Kernel is %dKB at 0x%x\n", mm_get_kernel_size() / 1024u, mm_get_kernel_address());
+}

src-old/hos_printf.c

@@ -0,0 +1,281 @@
+#include "hos_printf.h"
+#include <stdint.h>
+#include <stdbool.h>
+#include "string.h"
+
+static size_t format_dec(char * buffer, int32_t v)
+{
+    size_t sz = 0u;
+    bool printing = false;
+    if (v < 0)
+    {
+        buffer[sz++] = '-';
+        v = -v;
+    }
+    for (int32_t div = 1000000000; div >= 1; div /= 10)
+    {
+        int32_t digit = v / div;
+        v %= div;
+        if ((digit != 0) || (div == 1))
+        {
+            printing = true;
+        }
+        if (printing)
+        {
+            buffer[sz++] = digit + '0';
+        }
+    }
+    return sz;
+}
+
+static size_t format_dec64(char * buffer, int64_t v)
+{
+    size_t sz = 0u;
+    bool printing = false;
+    if (v < 0)
+    {
+        buffer[sz++] = '-';
+        v = -v;
+    }
+    for (int64_t div = 1000000000000000000; div >= 1; div /= 10)
+    {
+        int64_t digit = v / div;
+        v %= div;
+        if ((digit != 0) || (div == 1))
+        {
+            printing = true;
+        }
+        if (printing)
+        {
+            buffer[sz++] = digit + '0';
+        }
+    }
+    return sz;
+}
+
+static size_t format_udec(char * buffer, int32_t v)
+{
+    size_t sz = 0u;
+    for (int32_t div = 1000000000u; div >= 1u; div /= 10u)
+    {
+        int32_t digit = v / div;
+        v %= div;
+        if ((digit != 0) || (sz > 0u) || (div == 1))
+        {
+            buffer[sz++] = digit + '0';
+        }
+    }
+    return sz;
+}
+
+static size_t format_udec64(char * buffer, uint64_t v)
+{
+    size_t sz = 0u;
+    for (uint64_t div = 10000000000000000000u; div >= 1u; div /= 10u)
+    {
+        uint64_t digit = v / div;
+        v %= div;
+        if ((digit != 0) || (sz > 0u) || (div == 1))
+        {
+            buffer[sz++] = digit + '0';
+        }
+    }
+    return sz;
+}
+
+static size_t format_hex(char * buffer, uint32_t v, bool upper)
+{
+    const char upper_hex[] = "0123456789ABCDEF";
+    const char lower_hex[] = "0123456789abcdef";
+    size_t sz = 0u;
+    for (int i = 28; i >= 0; i -= 4)
+    {
+        uint8_t n = (v >> i) & 0xFu;
+        if ((sz > 0u) || (n != 0u) || (i == 0))
+        {
+            buffer[sz] = upper ? upper_hex[n] : lower_hex[n];
+            sz++;
+        }
+    }
+    return sz;
+}
+
+static size_t format_hex64(char * buffer, uint64_t v, bool upper)
+{
+    const char upper_hex[] = "0123456789ABCDEF";
+    const char lower_hex[] = "0123456789abcdef";
+    size_t sz = 0u;
+    for (int i = 60; i >= 0; i -= 4)
+    {
+        uint8_t n = (v >> i) & 0xFu;
+        if ((sz > 0u) || (n != 0u) || (i == 0))
+        {
+            buffer[sz] = upper ? upper_hex[n] : lower_hex[n];
+            sz++;
+        }
+    }
+    return sz;
+}
+
+static void pad_write(const stream_t * stream, const char * data, size_t length, bool leading_zero, bool left_just, size_t width)
+{
+    if (left_just)
+    {
+        stream->write(data, length);
+        while (length < width)
+        {
+            stream->write1(' ');
+            length++;
+        }
+    }
+    else
+    {
+        char fill = leading_zero ? '0' : ' ';
+        size_t l = length;
+        while (l < width)
+        {
+            stream->write1(fill);
+            l++;
+        }
+        stream->write(data, length);
+    }
+}
+
+void hos_vprintf(const stream_t * stream, const char * fmt, va_list va)
+{
+    bool in_conv = false;
+    char c;
+    char buffer[22];
+    size_t width;
+    bool leading_zero;
+    bool left_just;
+    bool long_flag;
+    size_t length;
+    while ((c = *fmt))
+    {
+        if (in_conv)
+        {
+            switch (c)
+            {
+            case '%':
+                stream->write1('%');
+                break;
+            case 'X':
+                {
+                    if (long_flag)
+                    {
+                        uint64_t v = va_arg(va, uint64_t);
+                        length = format_hex(buffer, v, true);
+                    }
+                    else
+                    {
+                        uint32_t v = va_arg(va, uint32_t);
+                        length = format_hex(buffer, v, true);
+                    }
+                    pad_write(stream, buffer, length, leading_zero, left_just, width);
+                }
+                break;
+            case 'c':
+                {
+                    char ch = va_arg(va, int);
+                    pad_write(stream, &ch, 1u, leading_zero, left_just, width);
+                }
+                break;
+            case 'd':
+                {
+                    if (long_flag)
+                    {
+                        int64_t v = va_arg(va, int64_t);
+                        length = format_dec64(buffer, v);
+                    }
+                    else
+                    {
+                        int32_t v = va_arg(va, int32_t);
+                        length = format_dec(buffer, v);
+                    }
+                    pad_write(stream, buffer, length, leading_zero, left_just, width);
+                }
+                break;
+            case 's':
+                {
+                    const char * s = va_arg(va, const char *);
+                    pad_write(stream, s, strlen(s), leading_zero, left_just, width);
+                }
+                break;
+            case 'u':
+                {
+                    if (long_flag)
+                    {
+                        uint64_t v = va_arg(va, uint64_t);
+                        length = format_udec64(buffer, v);
+                    }
+                    else
+                    {
+                        uint32_t v = va_arg(va, uint32_t);
+                        length = format_udec(buffer, v);
+                    }
+                    pad_write(stream, buffer, length, leading_zero, left_just, width);
+                }
+                break;
+            case 'x':
+                {
+                    if (long_flag)
+                    {
+                        uint64_t v = va_arg(va, uint64_t);
+                        length = format_hex64(buffer, v, false);
+                    }
+                    else
+                    {
+                        uint32_t v = va_arg(va, uint32_t);
+                        length = format_hex(buffer, v, false);
+                    }
+                    pad_write(stream, buffer, length, leading_zero, left_just, width);
+                }
+                break;
+            }
+            in_conv = false;
+        }
+        else if (c == '%')
+        {
+            in_conv = true;
+            width = 0u;
+            leading_zero = false;
+            left_just = false;
+            long_flag = false;
+            if (fmt[1] == '-')
+            {
+                left_just = true;
+                fmt++;
+            }
+            if (fmt[1] == '0')
+            {
+                leading_zero = true;
+                fmt++;
+            }
+            while (('0' <= fmt[1]) && (fmt[1] <= '9'))
+            {
+                width *= 10u;
+                width += (fmt[1] - '0');
+                fmt++;
+            }
+            if (fmt[1] == 'l')
+            {
+                long_flag = true;
+                fmt++;
+            }
+        }
+        else
+        {
+            stream->write1(c);
+        }
+        fmt++;
+    }
+}
+
+void hos_printf(const stream_t * stream, const char * fmt, ...)
+{
+    va_list va;
+    va_start(va, fmt);
+    hos_vprintf(stream, fmt, va);
+    va_end(va);
+}

src-old/hos_printf.h

@@ -0,0 +1,10 @@
+#ifndef HOS_PRINTF_H
+#define HOS_PRINTF_H
+
+#include "stream.h"
+#include <stdarg.h>
+
+void hos_vprintf(const stream_t * stream, const char * fmt, va_list va);
+void hos_printf(const stream_t * stream, const char * fmt, ...);
+
+#endif

src-old/klog.c

@@ -0,0 +1,103 @@
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdarg.h>
+#include "klog.h"
+#include "kfont.h"
+#include "fb.h"
+#include "fb_text.h"
+#include "stream.h"
+#include "hos_printf.h"
+#include "mem.h"
+
+static struct {
+    size_t console_width;
+    size_t console_height;
+    size_t x;
+    size_t y;
+    bool need_shift;
+} klog;
+
+static void shift_line(void)
+{
+    uint32_t * fb = fb_addr();
+    uint32_t w = fb_width();
+    size_t console_fb_line_words = w * kfont.line_height;
+    for (size_t row = 0u; row < klog.console_height; row++)
+    {
+        memcpy32(fb, fb + console_fb_line_words, console_fb_line_words);
+        fb += console_fb_line_words;
+    }
+    fb_fill(0, kfont.line_height * (klog.console_height - 1u), w, kfont.line_height, 0u, 0x2Cu, 0x55u);
+}
+
+static void klog_fb_write1(char c)
+{
+    if (klog.need_shift)
+    {
+        shift_line();
+        klog.need_shift = false;
+    }
+    if (c == '\n')
+    {
+        if (klog.y == (klog.console_height - 1u))
+        {
+            klog.need_shift = true;
+        }
+        else
+        {
+            klog.y++;
+        }
+        klog.x = 0u;
+    }
+    else
+    {
+        int px = klog.x * kfont.advance;
+        int py = klog.y * kfont.line_height;
+        fb_text_render_char(c, px, py, 0xFFu, 0x80u, 0u);
+        klog.x++;
+        if (klog.x == klog.console_width)
+        {
+            if (klog.y == (klog.console_height - 1u))
+            {
+                klog.need_shift = true;
+            }
+            else
+            {
+                klog.y++;
+            }
+            klog.x = 0u;
+        }
+    }
+}
+
+static void klog_fb_write(const char * src, size_t length)
+{
+    for (size_t i = 0u; i < length; i++)
+    {
+        klog_fb_write1(src[i]);
+    }
+}
+
+static const stream_t klog_fb_stream = {
+    klog_fb_write,
+    klog_fb_write1,
+};
+
+void klog_init(void)
+{
+    klog.console_width = fb_width() / kfont.advance;
+    klog.console_height = fb_height() / kfont.line_height;
+    klog.x = 0u;
+    klog.y = 0u;
+    klog.need_shift = false;
+    fb_fill(0, 0, fb_width(), fb_height(), 0u, 0x2Cu, 0x55u);
+}
+
+void klog_printf(const char * fmt, ...)
+{
+    va_list va;
+    va_start(va, fmt);
+    hos_vprintf(&klog_fb_stream, fmt, va);
+    va_end(va);
+}

src-old/klog.h

@@ -0,0 +1,7 @@
+#ifndef KLOG_H
+#define KLOG_H
+
+void klog_init(void);
+void klog_printf(const char * fmt, ...);
+
+#endif

src-old/link.ld

@@ -0,0 +1,41 @@
+ENTRY(hos_start)
+
+SECTIONS
+{
+    . = 1M;
+    _hos_mem_start = .;
+
+    .text BLOCK(4K) : ALIGN(4K)
+    {
+        *(.multiboot)
+        *(.text)
+    }
+
+    .rodata BLOCK(4K) : ALIGN(4K)
+    {
+        *(.rodata)
+    }
+
+    .data BLOCK(4K) : ALIGN(4K)
+    {
+        *(.data)
+    }
+
+    _stack_size = 16K;
+    .stack (NOLOAD) : ALIGN(4K)
+    {
+        _stack_start = .;
+        . = . + _stack_size;
+        _stack_end = .;
+    }
+
+    .bss BLOCK(4K) : ALIGN(4K)
+    {
+        *(COMMON)
+        *(.bss)
+    }
+
+    . = ALIGN(4K);
+
+    _hos_mem_end = .;
+}

src-old/mbinfo.c

@@ -0,0 +1,100 @@
+#include "multiboot2.h"
+#include "fb.h"
+#include "mem.h"
+#include <stdint.h>
+#include "klog.h"
+#include "mm.h"
+
+static uint32_t mbinfo[2048];
+
+static void mbinfo_process_tag(const multiboot2_info_tag_t * tag)
+{
+    switch (tag->type)
+    {
+    case MULTIBOOT2_INFO_BOOT_COMMAND_LINE:
+        {
+            multiboot2_info_boot_command_line_t * cl =
+                (multiboot2_info_boot_command_line_t *)tag;
+            klog_printf("Kernel boot command line: '%s'\n", cl->string);
+        }
+        break;
+
+    case MULTIBOOT2_INFO_BOOT_LOADER_NAME:
+        {
+            multiboot2_info_boot_loader_name_t * bln =
+                (multiboot2_info_boot_loader_name_t *)tag;
+            klog_printf("Boot loader: '%s'\n", bln->string);
+        }
+        break;
+
+    case MULTIBOOT2_INFO_MEMORY_MAP:
+        {
+            multiboot2_info_memory_map_t * mmap_info =
+                (multiboot2_info_memory_map_t *)tag;
+            size_t sz = sizeof(mmap_info->header) +
+                sizeof(mmap_info->entry_size) +
+                sizeof(mmap_info->entry_version);
+            multiboot2_info_memory_map_entry_t * entry = &mmap_info->entries[0];
+            for (;;)
+            {
+                sz += mmap_info->entry_size;
+                if (sz > mmap_info->header.size)
+                {
+                    break;
+                }
+                if (entry->type == MULTIBOOT2_MEMORY_MAP_TYPE_RAM)
+                {
+                    klog_printf("Memory region %16lx : %16lx\n",
+                            entry->base_addr,
+                            entry->length);
+                    mm_register_ram_region(entry->base_addr, entry->length);
+                }
+                entry = (multiboot2_info_memory_map_entry_t *)((uintptr_t)entry + mmap_info->entry_size);
+            }
+        }
+        break;
+
+    case MULTIBOOT2_INFO_FRAMEBUFFER_INFO:
+        {
+            multiboot2_info_framebuffer_info_t * fbinfo =
+                (multiboot2_info_framebuffer_info_t *)tag;
+            fb_init((uint32_t *)(uintptr_t)fbinfo->framebuffer_addr,
+                    fbinfo->framebuffer_width,
+                    fbinfo->framebuffer_height,
+                    fbinfo->framebuffer_pitch);
+        }
+        break;
+    }
+}
+
+static void process_tags(const multiboot2_info_tag_t * tag, bool init)
+{
+    while (tag->type != 0u)
+    {
+        if ((init && (tag->type == MULTIBOOT2_INFO_FRAMEBUFFER_INFO)) ||
+                (!init && (tag->type != MULTIBOOT2_INFO_FRAMEBUFFER_INFO)))
+        {
+            mbinfo_process_tag(tag);
+        }
+        tag = multiboot2_info_next_tag(tag);
+    }
+}
+
+bool mbinfo_init(uint32_t mbinfo_addr)
+{
+    multiboot2_info_header_t * mbinfo_header = (multiboot2_info_header_t *)mbinfo_addr;
+    if (mbinfo_header->total_size <= sizeof(mbinfo))
+    {
+        memcpy32(mbinfo, mbinfo_header, mbinfo_header->total_size / 4u);
+        multiboot2_info_tag_t * tag = (multiboot2_info_tag_t *)(mbinfo + sizeof(multiboot2_info_header_t) / 4u);
+        process_tags(tag, true);
+        return true;
+    }
+    return false;
+}
+
+void mbinfo_load(void)
+{
+    multiboot2_info_tag_t * tag = (multiboot2_info_tag_t *)(mbinfo + sizeof(multiboot2_info_header_t) / 4u);
+    process_tags(tag, false);
+}

src-old/mbinfo.h

@@ -0,0 +1,10 @@
+#ifndef MBINFO_H
+#define MBINFO_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+bool mbinfo_init(uint32_t mbinfo_addr);
+void mbinfo_load(void);
+
+#endif

src-old/mem.h

@@ -0,0 +1,49 @@
+#ifndef MEM_H
+#define MEM_H
+
+#include <stddef.h>
+
+static inline void memcpy(void * dest, const void * src, size_t n)
+{
+    uint32_t r0, r1, r2;
+    __asm__ __volatile__ (
+            "cld\n\t"
+            "rep movsb"
+            : "=&c" (r0), "=&S" (r1), "=&D" (r2)
+            : "2" (dest), "1" (src), "0" (n)
+            : "memory");
+}
+
+static inline void memcpy32(void * dest, const void * src, size_t count)
+{
+    uint32_t r0, r1, r2;
+    __asm__ __volatile__ (
+            "cld\n\t"
+            "rep movsd"
+            : "=&c" (r0), "=&S" (r1), "=&D" (r2)
+            : "2" (dest), "1" (src), "0" (count)
+            : "memory");
+}
+
+static inline void * memmove(void * dest, const void * src, size_t count)
+{
+    return __builtin_memmove(dest, src, count);
+}
+
+static inline void * memset(void * dest, int val, size_t count)
+{
+    return __builtin_memset(dest, val, count);
+}
+
+static inline void memset32(void * dest, uint32_t val, size_t count)
+{
+    uint32_t r0, r1;
+    __asm__ __volatile__ (
+            "cld\n\t"
+            "rep stosl"
+            : "=&c" (r0), "=&D" (r1)
+            : "a" (val), "1" (dest), "0" (count)
+            : "memory");
+}
+
+#endif

src-old/mm.c

@@ -0,0 +1,91 @@
+#include "mm.h"
+
+typedef struct mm_page_entry_s {
+    size_t count;
+    struct mm_page_entry_s * next;
+} mm_region_entry_t;
+
+static mm_region_entry_t * mm_next_free_region;
+static size_t mm_free_pages;
+static size_t mm_total_ram;
+static size_t kernel_start_address;
+static size_t kernel_size;
+
+extern uint8_t _hos_mem_start;
+extern uint8_t _hos_mem_end;
+
+static void mm_add_ram_region(size_t base, size_t size)
+{
+    mm_region_entry_t * region = (mm_region_entry_t *)base;
+    size_t pages = size / PAGE_SIZE;
+    region->count = pages;
+    region->next = mm_next_free_region;
+    mm_next_free_region = region;
+    mm_total_ram += size;
+    mm_free_pages = pages;
+}
+
+void mm_register_ram_region(uint64_t base, size_t size)
+{
+    /* Ignore any RAM region above 4GB. */
+    if (base >= 0x100000000ull)
+    {
+        return;
+    }
+    if ((base + size) > 0x100000000ull)
+    {
+        size = (size_t)(0x100000000ull - base);
+    }
+    size_t end_address = mm_page_floor((size_t)base + size);
+    size_t start_address = mm_page_ceil(base);
+    size = end_address - start_address;
+    if (size < PAGE_SIZE)
+    {
+        return;
+    }
+    size_t kernel_end_address = kernel_start_address + kernel_size;
+    /* Add regions before and after kernel RAM. */
+    if (start_address < kernel_start_address)
+    {
+        /* RAM region begins before kernel RAM. */
+        size_t this_sz = size;
+        if ((start_address + this_sz) > kernel_start_address)
+        {
+            this_sz = kernel_start_address - start_address;
+        }
+        mm_add_ram_region(start_address, this_sz);
+    }
+    if ((start_address + size) > kernel_end_address)
+    {
+        /* RAM region ends after kernel RAM. */
+        size_t this_sz = size;
+        if (start_address < kernel_end_address)
+        {
+            this_sz = (start_address + size) - kernel_end_address;
+            start_address = kernel_end_address;
+        }
+        mm_add_ram_region(start_address, this_sz);
+    }
+}
+
+void mm_init(void)
+{
+    kernel_start_address = mm_page_floor((size_t)&_hos_mem_start);
+    kernel_size = mm_page_ceil((size_t)&_hos_mem_end - kernel_start_address);
+    mm_total_ram = kernel_size;
+}
+
+size_t mm_get_total_ram(void)
+{
+    return mm_total_ram;
+}
+
+size_t mm_get_kernel_address(void)
+{
+    return kernel_start_address;
+}
+
+size_t mm_get_kernel_size(void)
+{
+    return kernel_size;
+}

src-old/mm.h

@@ -0,0 +1,25 @@
+#ifndef MM_H
+#define MM_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+#define PAGE_SIZE 4096u
+
+static inline size_t mm_page_floor(size_t bytes)
+{
+    return bytes & ~(PAGE_SIZE - 1u);
+}
+
+static inline size_t mm_page_ceil(size_t bytes)
+{
+    return (bytes + PAGE_SIZE - 1u) & ~(PAGE_SIZE - 1u);
+}
+
+void mm_init(void);
+void mm_register_ram_region(uint64_t base, size_t size);
+size_t mm_get_total_ram(void);
+size_t mm_get_kernel_address(void);
+size_t mm_get_kernel_size(void);
+
+#endif

src-old/multiboot2.h

@@ -0,0 +1,127 @@
+#ifndef MULTIBOOT2_H
+#define MULTIBOOT2_H
+
+#include <stdint.h>
+
+#define MULTIBOOT2_MAGIC 0xE85250D6u
+#define MULTIBOOT2_ARCHITECTURE_I386 0u
+
+typedef struct {
+    uint32_t magic;
+    uint32_t architecture;
+    uint32_t header_length;
+    uint32_t checksum;
+} multiboot2_header_t;
+#define multiboot2_header(magic, architecture, header_length) \
+    {(magic), (architecture), (header_length), (uint32_t)(0x100000000u - (magic) - (architecture) - (header_length))}
+#define multiboot2_header_default() \
+    multiboot2_header(MULTIBOOT2_MAGIC, MULTIBOOT2_ARCHITECTURE_I386, sizeof(multiboot2_header_t))
+
+typedef struct {
+    uint16_t type;
+    uint16_t flags;
+    uint32_t size;
+} multiboot2_tag_t;
+#define multiboot2_end_tag() {0u, 0u, 8u}
+
+typedef struct {
+    multiboot2_tag_t header;
+    uint32_t width;
+    uint32_t height;
+    uint32_t depth;
+    uint32_t _padding;
+} multiboot2_framebuffer_tag_t;
+#define multiboot2_framebuffer_tag(width, height, depth) \
+    {{5u, 0u, 20u}, width, height, depth}
+
+#define MULTIBOOT2_INFO_TAG_ALIGNMENT 8u
+#define MULTIBOOT2_INFO_BOOT_COMMAND_LINE 1u
+#define MULTIBOOT2_INFO_BOOT_LOADER_NAME 2u
+#define MULTIBOOT2_INFO_MODULES 3u
+#define MULTIBOOT2_INFO_BASIC_MEMORY_INFO 4u
+#define MULTIBOOT2_INFO_BIOS_BOOT_DEVICE 5u
+#define MULTIBOOT2_INFO_MEMORY_MAP 6u
+#define MULTIBOOT2_INFO_VBE_INFO 7u
+#define MULTIBOOT2_INFO_FRAMEBUFFER_INFO 8u
+#define MULTIBOOT2_INFO_ELF_SYMBOLS 9u
+#define MULTIBOOT2_INFO_APM_TABLE 10u
+#define MULTIBOOT2_INFO_EFI_32BIT_SYSTEM_TABLE_POINTER 11u
+#define MULTIBOOT2_INFO_EFI_64BIT_SYSTEM_TABLE_POINTER 12u
+#define MULTIBOOT2_INFO_SMBIOS_TABLES 13u
+#define MULTIBOOT2_INFO_ACPI_OLD_RSDP 14u
+#define MULTIBOOT2_INFO_NETWORKING_INFO 16u
+#define MULTIBOOT2_INFO_EFI_MEMORY_MAP 17u
+#define MULTIBOOT2_INFO_EFI_BOOT_SERVICES_NOT_TERMINATED 18u
+#define MULTIBOOT2_INFO_EFI_32BIT_IMAGE_HANDLE_POINTER 19u
+#define MULTIBOOT2_INFO_EFI_64BIT_IMAGE_HANDLE_POINTER 20u
+#define MULTIBOOT2_INFO_IMAGE_LOAD_BASE_PHYSICAL_ADDRESS 21u
+
+typedef struct {
+    uint32_t total_size;
+    uint32_t _reserved;
+} multiboot2_info_header_t;
+
+typedef struct {
+    uint32_t type;
+    uint32_t size;
+} multiboot2_info_tag_t;
+#define multiboot2_info_next_tag(current_tag) \
+    (multiboot2_info_tag_t *)(((uintptr_t)current_tag + current_tag->size + MULTIBOOT2_INFO_TAG_ALIGNMENT - 1u) & ~(MULTIBOOT2_INFO_TAG_ALIGNMENT - 1u))
+
+typedef struct {
+    multiboot2_info_tag_t header;
+    char string[];
+} multiboot2_info_boot_command_line_t;
+
+typedef struct {
+    multiboot2_info_tag_t header;
+    char string[];
+} multiboot2_info_boot_loader_name_t;
+
+typedef struct {
+    multiboot2_info_tag_t header;
+    uint32_t mem_lower;
+    uint32_t mem_upper;
+} multiboot2_info_basic_memory_info_t;
+
+#define MULTIBOOT2_MEMORY_MAP_TYPE_RAM 1u
+#define MULTIBOOT2_MEMORY_MAP_TYPE_ACPI 3u
+#define MULTIBOOT2_MEMORY_MAP_TYPE_PRESERVE 4u
+#define MULTIBOOT2_MEMORY_MAP_TYPE_DEFECTIVE 5u
+
+typedef struct {
+    uint64_t base_addr;
+    uint64_t length;
+    uint32_t type;
+    uint32_t _reserved;
+} multiboot2_info_memory_map_entry_t;
+
+typedef struct {
+    multiboot2_info_tag_t header;
+    uint32_t entry_size;
+    uint32_t entry_version;
+    multiboot2_info_memory_map_entry_t entries[];
+} multiboot2_info_memory_map_t;
+
+typedef struct {
+    multiboot2_info_tag_t header;
+    uint16_t vbe_mode;
+    uint16_t vbe_interface_set;
+    uint16_t vbe_interface_off;
+    uint16_t vbe_interface_len;
+    uint8_t vbe_control_info[512];
+    uint8_t vbe_mode_info[256];
+} multiboot2_info_vbe_info_t;
+
+typedef struct {
+    multiboot2_info_tag_t header;
+    uint64_t framebuffer_addr;
+    uint32_t framebuffer_pitch;
+    uint32_t framebuffer_width;
+    uint32_t framebuffer_height;
+    uint8_t framebuffer_bpp;
+    uint8_t framebuffer_type;
+    uint8_t _reserved;
+} multiboot2_info_framebuffer_info_t;
+
+#endif

src-old/multiboot_header.c

@@ -0,0 +1,12 @@
+#include "multiboot2.h"
+
+/* Multiboot2 Header. */
+struct {
+    multiboot2_header_t header;
+    multiboot2_framebuffer_tag_t framebuffer_tag;
+    multiboot2_tag_t end_tag;
+} multiboot_header __attribute__((section(".multiboot"))) = {
+    multiboot2_header_default(),
+    multiboot2_framebuffer_tag(1600u, 900u, 32u),
+    multiboot2_end_tag(),
+};

src-old/stream.h

@@ -0,0 +1,12 @@
+#ifndef STREAM_H
+#define STREAM_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+typedef struct {
+    void (*write)(const char * src, size_t length);
+    void (*write1)(char c);
+} stream_t;
+
+#endif

src-old/string.h

@@ -0,0 +1,26 @@
+#ifndef STRING_H
+#define STRING_H
+
+#include <stddef.h>
+
+static inline size_t strlen(const char * s)
+{
+    size_t r = 0u;
+    while (*s++ != (char)0)
+    {
+        r++;
+    }
+    return r;
+}
+
+static inline char * strcpy(char * dest, const char * src)
+{
+    return __builtin_strcpy(dest, src);
+}
+
+static inline char * strncpy(char * dest, const char * src, size_t n)
+{
+    return __builtin_strncpy(dest, src, n);
+}
+
+#endif

src/common/hos/cpu.d

@@ -0,0 +1,26 @@
+import ldc.llvmasm;
+
+ulong read_cr0()
+{
+    return __asm!ulong("mov %cr0, %rax", "={rax}");
+}
+
+ulong read_cr2()
+{
+    return __asm!ulong("mov %cr2, %rax", "={rax}");
+}
+
+ulong read_cr3()
+{
+    return __asm!ulong("mov %cr3, %rax", "={rax}");
+}
+
+void write_cr3(ulong v)
+{
+    __asm("mov $0, %cr3", "r", v);
+}
+
+ulong read_cr4()
+{
+    return __asm!ulong("mov %cr4, %rax", "={rax}");
+}

src/common/hos/memory.d

@@ -0,0 +1,57 @@
+import ldc.llvmasm;
+
+void memset(void * dest, ubyte v, size_t n)
+{
+    __asm("rep stosb",
+          "{al},{rcx},{rdi},~{rcx},~{rdi},~{memory}",
+          v, n, dest);
+}
+
+void memset16(void * dest, ushort v, size_t n)
+{
+    __asm("rep stosw",
+          "{ax},{rcx},{rdi},~{rcx},~{rdi},~{memory}",
+          v, n, dest);
+}
+
+void memset32(void * dest, uint v, size_t n)
+{
+    __asm("rep stosl",
+          "{eax},{rcx},{rdi},~{rcx},~{rdi},~{memory}",
+          v, n, dest);
+}
+
+void memset64(void * dest, ulong v, size_t n)
+{
+    __asm("rep stosq",
+          "{rax},{rcx},{rdi},~{rcx},~{rdi},~{memory}",
+          v, n, dest);
+}
+
+void memcpy(void * dest, void * src, size_t n)
+{
+    __asm("rep movsb",
+          "{rcx},{rsi},{rdi},~{rcx},~{rsi},~{rdi},~{memory}",
+          n, src, dest);
+}
+
+void memcpy16(void * dest, void * src, size_t n)
+{
+    __asm("rep movsw",
+          "{rcx},{rsi},{rdi},~{rcx},~{rsi},~{rdi},~{memory}",
+          n, src, dest);
+}
+
+void memcpy32(void * dest, void * src, size_t n)
+{
+    __asm("rep movsl",
+          "{rcx},{rsi},{rdi},~{rcx},~{rsi},~{rdi},~{memory}",
+          n, src, dest);
+}
+
+void memcpy64(void * dest, void * src, size_t n)
+{
+    __asm("rep movsq",
+          "{rcx},{rsi},{rdi},~{rcx},~{rsi},~{rdi},~{memory}",
+          n, src, dest);
+}

src/common/hos/page_table.d

@@ -0,0 +1,33 @@
+struct PageTableEntry
+{
+    ulong entry;
+
+    this(ulong address, ulong no_execute, ulong global,
+            ulong huge, ulong disable_cache, ulong write_through, ulong user,
+            ulong writable, ulong present)
+    {
+        entry = (present |
+                (writable << 1) |
+                (user << 2) |
+                (write_through << 3) |
+                (disable_cache << 4) |
+                (huge << 7) |
+                (global << 8) |
+                (no_execute << 63)) | address;
+    }
+
+    bool present()
+    {
+        return (entry & 0x1u) != 0u;
+    }
+
+    PageTableEntry * next()
+    {
+        return cast(PageTableEntry *)(entry & 0x7FFF_FFFF_FFFF_F000u);
+    }
+
+    static ulong page_table_index(ulong address, size_t level)
+    {
+        return ((address >> (39u - 9u * level)) & 0x1FFu);
+    }
+}

src/fontgen/fontgen.c

@@ -0,0 +1,224 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <ft2build.h>
+#include <stdio.h>
+#include FT_FREETYPE_H
+#include <string.h>
+#include <strings.h>
+#include <ctype.h>
+
+#define N_CHARS 128
+
+#define round_up_26_6(val) (((val) + 63) >> 6u)
+
+int max_advance;
+int max_top = -9999;
+int min_bottom = 9999;
+int line_height;
+int baseline_offset;
+
+typedef struct {
+    int width;
+    int height;
+    int top;
+    int left;
+    uint8_t * bitmap;
+} char_info_t;
+
+static char_info_t char_infos[N_CHARS];
+
+static void load_char(FT_Face face, int char_code)
+{
+    if (FT_Load_Char(face, char_code, FT_LOAD_RENDER) != 0)
+    {
+        return;
+    }
+    int advance = round_up_26_6(face->glyph->advance.x);
+    if (advance > max_advance)
+    {
+        max_advance = advance;
+    }
+    if ((face->glyph->bitmap.width == 0) ||
+            (face->glyph->bitmap.rows == 0))
+    {
+        return;
+    }
+    char_infos[char_code].width = face->glyph->bitmap.width;
+    char_infos[char_code].height = face->glyph->bitmap.rows;
+    char_infos[char_code].top = face->glyph->bitmap_top;
+    if (char_infos[char_code].top > max_top)
+    {
+        max_top = char_infos[char_code].top;
+    }
+    int bottom = char_infos[char_code].top - char_infos[char_code].height;
+    if (bottom < min_bottom)
+    {
+        min_bottom = bottom;
+    }
+    char_infos[char_code].left = face->glyph->bitmap_left;
+    char_infos[char_code].bitmap = malloc(char_infos[char_code].width * char_infos[char_code].height);
+    memcpy(char_infos[char_code].bitmap,
+            face->glyph->bitmap.buffer,
+            char_infos[char_code].width * char_infos[char_code].height);
+}
+
+static const char * bare_header_name(const char * h_file_name)
+{
+    const char * p = rindex(h_file_name, '/');
+    if (p == NULL)
+    {
+        p = h_file_name;
+    }
+    else
+    {
+        p++;
+    }
+    return p;
+}
+
+static char * include_guard_name(const char * h_file_name)
+{
+    const char * p = bare_header_name(h_file_name);
+    char * guard_name = malloc(strlen(p) + 1);
+    strcpy(guard_name, p);
+    char * m = guard_name;
+    while (*m != '\0')
+    {
+        if ('a' <= *m && *m <= 'z')
+        {
+            *m = toupper(*m);
+        }
+        else if (('0' <= *m && *m <= '9') || ('A' <= *m && *m <= 'Z'))
+        {
+            /* no change */
+        }
+        else
+        {
+            *m = '_';
+        }
+        m++;
+    }
+    return guard_name;
+}
+
+static void generate_bytes(FILE * file, const uint8_t * bytes, int count)
+{
+    for (int i = 0; i < count; i++)
+    {
+        if (i % 8 == 0)
+        {
+            fprintf(file, "    ");
+        }
+        fprintf(file, "0x%02xu,", bytes[i]);
+        if ((i + 1) % 8 == 0)
+        {
+            fprintf(file, "\n");
+        }
+        else if (i < (count - 1))
+        {
+            fprintf(file, " ");
+        }
+    }
+    if (count % 8 != 0)
+    {
+        fprintf(file, "\n");
+    }
+}
+
+static void generate(const char * c_file_name)
+{
+    char * h_file_name = malloc(strlen(c_file_name) + 1);
+    strcpy(h_file_name, c_file_name);
+    h_file_name[strlen(h_file_name) - 1] = 'h';
+    char * guard = include_guard_name(h_file_name);
+
+    FILE * h_file = fopen(h_file_name, "wb");
+    fprintf(h_file, "#ifndef %s\n", guard);
+    fprintf(h_file, "#define %s\n\n", guard);
+    fprintf(h_file, "#include <stdint.h>\n");
+    fprintf(h_file, "typedef struct {\n    int width;\n    int height;\n    int top;\n    int left;\n    const uint8_t * bitmap;\n} fontgen_char_info_t;\n");
+    fprintf(h_file, "typedef struct {\n    int line_height;\n    int advance;\n    int baseline_offset;\n    const fontgen_char_info_t ** char_infos;\n} fontgen_font_t;\n");
+    fprintf(h_file, "extern const fontgen_font_t kfont;\n");
+    fprintf(h_file, "#endif\n");
+    fclose(h_file);
+
+    FILE * c_file = fopen(c_file_name, "wb");
+    fprintf(c_file, "#include \"%s\"\n", bare_header_name(h_file_name));
+    fprintf(c_file, "#include <stddef.h>\n");
+    for (int i = 0; i < N_CHARS; i++)
+    {
+        if (char_infos[i].width > 0)
+        {
+            fprintf(c_file, "static const uint8_t char_bitmap_%d[] = {\n", i);
+            generate_bytes(c_file, char_infos[i].bitmap, char_infos[i].width * char_infos[i].height);
+            fprintf(c_file, "};\n");
+        }
+        fprintf(c_file, "static const fontgen_char_info_t char_%d = {\n", i);
+        fprintf(c_file, "    %d,\n", char_infos[i].width);
+        fprintf(c_file, "    %d,\n", char_infos[i].height);
+        fprintf(c_file, "    %d,\n", char_infos[i].top);
+        fprintf(c_file, "    %d,\n", char_infos[i].left);
+        if (char_infos[i].width > 0)
+        {
+            fprintf(c_file, "    char_bitmap_%d,\n", i);
+        }
+        else
+        {
+            fprintf(c_file, "    NULL,\n");
+        }
+        fprintf(c_file, "};\n\n");
+    }
+    fprintf(c_file, "const fontgen_char_info_t * char_infos[] = {\n");
+    for (int i = 0; i < N_CHARS; i++)
+    {
+        fprintf(c_file, "    &char_%d,\n", i);
+    }
+    fprintf(c_file, "};\n");
+    fprintf(c_file, "const fontgen_font_t kfont = {\n");
+    fprintf(c_file, "    %d,\n", line_height);
+    fprintf(c_file, "    %d,\n", max_advance);
+    fprintf(c_file, "    %d,\n", baseline_offset);
+    fprintf(c_file, "    char_infos,\n");
+    fprintf(c_file, "};\n");
+    fclose(c_file);
+}
+
+int main(int argc, char * argv[])
+{
+    /* Expect: font file, size, out file */
+    if (argc != 4)
+    {
+        fprintf(stderr, "Incorrect arguments\n");
+        return 1;
+    }
+    const char * font_file = argv[1];
+    int size = atoi(argv[2]);
+    const char * out_file = argv[3];
+
+    FT_Library ft_library;
+    if (FT_Init_FreeType(&ft_library) != 0)
+    {
+        fprintf(stderr, "Could not initialize freetype\n");
+        return 2;
+    }
+
+    FT_Face face;
+    if (FT_New_Face(ft_library, font_file, 0, &face) != 0)
+    {
+        fprintf(stderr, "Could not open %s\n", font_file);
+        return 3;
+    }
+
+    FT_Set_Pixel_Sizes(face, 0, size);
+
+    for (int i = 0; i < N_CHARS; i++)
+    {
+        load_char(face, i);
+    }
+    line_height = round_up_26_6(face->size->metrics.height);
+    baseline_offset = (line_height - (max_top - min_bottom)) / 2 - min_bottom;
+
+    generate(out_file);
+
+    return 0;
+}

src/hello/hello.d

@@ -0,0 +1,240 @@
+import uefi;
+import output;
+import scratch;
+import hulk.bootinfo;
+import hos.page_table;
+import hos.cpu;
+import hos.memory;
+
+__gshared EFI_SYSTEM_TABLE * st;
+__gshared BootInfo bootinfo;
+__gshared UINTN memory_map_key;
+extern extern(C) __gshared ubyte hulk_start;
+extern extern(C) __gshared ubyte hulk_end;
+
+private void wait_key()
+{
+    writeln("Press any key...");
+    st.ConIn.Reset(st.ConIn, FALSE);
+    EFI_INPUT_KEY key;
+    while (st.ConIn.ReadKeyStroke(st.ConIn, &key) == EFI_NOT_READY)
+    {
+    }
+}
+
+private bool in_qemu()
+{
+    ulong * firmware_vendor = cast(ulong *) st.FirmwareVendor;
+    ulong fv1 = firmware_vendor[0];
+    return fv1 ==
+        ((cast(ulong)'E') |
+         (cast(ulong)'D' << 16) |
+         (cast(ulong)'K' << 32) |
+         (cast(ulong)' ' << 48));
+}
+
+private bool set_graphics_mode()
+{
+    uint max_horizontal_resolution = in_qemu() ? 1920u : 0xFFFFFFFFu;
+    UINTN buffer_size = scratch_free();
+    EFI_GUID gop_guid = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
+    EFI_HANDLE * handles = cast(EFI_HANDLE *)scratch_current();
+    EFI_STATUS status = st.BootServices.LocateHandle(ByProtocol,
+            &gop_guid, null, &buffer_size, handles);
+    if (status != EFI_SUCCESS)
+    {
+        writeln("LocateHandle: error %x", status);
+        return false;
+    }
+    EFI_HANDLE gop_handle = handles[0];
+    EFI_HANDLE gop_interface;
+    status = st.BootServices.HandleProtocol(gop_handle,
+            &gop_guid, &gop_interface);
+    if (status != EFI_SUCCESS)
+    {
+        writeln("HandleProtocol: error %x", status);
+        return false;
+    }
+    if (gop_interface == null)
+    {
+        writeln("null interface from HandleProtocol");
+        return false;
+    }
+    EFI_GRAPHICS_OUTPUT_PROTOCOL * gop = cast(EFI_GRAPHICS_OUTPUT_PROTOCOL *)gop_interface;
+    UINTN info_size;
+    EFI_GRAPHICS_OUTPUT_MODE_INFORMATION * info;
+    uint best_width;
+    uint best_mode_number;
+    for (uint mode_number = 0u;
+         (status = gop.QueryMode(gop, mode_number, &info_size, &info)) == EFI_SUCCESS;
+         mode_number++)
+    {
+        if ((info.HorizontalResolution > best_width) &&
+            (info.HorizontalResolution <= max_horizontal_resolution))
+        {
+            best_width = info.HorizontalResolution;
+            best_mode_number = mode_number;
+        }
+        st.BootServices.FreePool(info);
+    }
+    if ((status = gop.SetMode(gop, best_mode_number)) != EFI_SUCCESS)
+    {
+        writeln("SetMode: Error %x\n", status);
+        return false;
+    }
+    bootinfo.fb.buffer = cast(uint *)gop.Mode.FrameBufferBase;
+    bootinfo.fb.width = gop.Mode.Info.HorizontalResolution;
+    bootinfo.fb.height = gop.Mode.Info.VerticalResolution;
+    bootinfo.fb.stride = gop.Mode.Info.PixelsPerScanLine;
+    bootinfo.fb.format = gop.Mode.Info.PixelFormat;
+    return true;
+}
+
+private bool get_memory_map()
+{
+    UINTN memory_map_size = scratch_free();
+    UINTN descriptor_size;
+    UINT32 descriptor_version;
+    ubyte * scratch_base = scratch_current();
+    UINTN status = st.BootServices.GetMemoryMap(
+            &memory_map_size,
+            cast(EFI_MEMORY_DESCRIPTOR *)scratch_base,
+            &memory_map_key,
+            &descriptor_size,
+            &descriptor_version);
+    if (status != EFI_SUCCESS)
+    {
+        writeln("GetMemoryMap: Error %x", status);
+        return false;
+    }
+    size_t n_entries = memory_map_size / descriptor_size;
+    size_t di;
+    for (size_t i = 0u; i < n_entries; i++)
+    {
+        EFI_MEMORY_DESCRIPTOR * descriptor = cast(EFI_MEMORY_DESCRIPTOR *)&scratch_base[i * descriptor_size];
+        if ((descriptor.Type == EfiLoaderCode) ||
+            (descriptor.Type == EfiLoaderData) ||
+            (descriptor.Type == EfiBootServicesCode) ||
+            (descriptor.Type == EfiBootServicesCode) ||
+            (descriptor.Type == EfiConventionalMemory))
+        {
+            bootinfo.memory_map[di].base = descriptor.PhysicalStart;
+            bootinfo.memory_map[di].size = descriptor.NumberOfPages * 4096u;
+            di++;
+        }
+    }
+    bootinfo.memory_map_count = di;
+    return true;
+}
+
+private PageTableEntry * new_page_table()
+{
+    PageTableEntry * pt = cast(PageTableEntry *)scratch_alloc(1u);
+    memset64(pt, 0u, 512);
+    return pt;
+}
+
+private void map(ulong source_page, ulong dest_page, PageTableEntry * pt_base)
+{
+    PageTableEntry * pt = pt_base;
+    PageTableEntry * next_pt;
+    for (size_t level = 0; level < 4u; level++)
+    {
+        size_t pt_index = PageTableEntry.page_table_index(source_page, level);
+        if (pt[pt_index].present())
+        {
+            pt = pt[pt_index].next();
+        }
+        else
+        {
+            ulong addr;
+            if (level < 3u)
+            {
+                next_pt = new_page_table();
+                addr = cast(ulong)next_pt;
+            }
+            else
+            {
+                addr = dest_page;
+            }
+            pt[pt_index] = PageTableEntry(addr,
+                    0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u);
+            pt = next_pt;
+        }
+    }
+}
+
+private void map_hulk(PageTableEntry * pt_base)
+{
+    ulong virt = HULK_VIRTUAL_START;
+    ulong phys = cast(ulong)&hulk_start;
+    while (phys < cast(ulong)&hulk_end)
+    {
+        map(virt, phys, pt_base);
+        virt += 4096u;
+        phys += 4096u;
+    }
+}
+
+private void build_page_tables()
+{
+    PageTableEntry * pt_base = new_page_table();
+    for (size_t i = 0u; i < bootinfo.memory_map_count; i++)
+    {
+        size_t n_pages = bootinfo.memory_map[i].size / 4096u;
+        for (size_t p = 0u; p < n_pages; p++)
+        {
+            ulong page_addr = bootinfo.memory_map[i].base + 4096u * p;
+            /* Identity map all pages. */
+            map(page_addr, page_addr, pt_base);
+        }
+    }
+    map_hulk(pt_base);
+    write_cr3(cast(ulong)pt_base);
+}
+
+private void jump_to_hulk()
+{
+    void function(BootInfo *) hulk_start = cast(void function(BootInfo *))HULK_VIRTUAL_START;
+    hulk_start(&bootinfo);
+}
+
+extern (C) EFI_STATUS efi_main(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE * st)
+{
+    .st = st;
+
+    st.ConOut.ClearScreen(st.ConOut);
+
+    writeln("HELLO, HOS EFI Lightweight LOader, v0.1.0");
+    writeln("Firmware vendor: '%S', version: 0x%x", st.FirmwareVendor, st.FirmwareVendor);
+
+    if (!set_graphics_mode())
+    {
+        wait_key();
+        return EFI_SUCCESS;
+    }
+
+    for (;;)
+    {
+        get_memory_map();
+
+        EFI_STATUS status = st.BootServices.ExitBootServices(image_handle, memory_map_key);
+        if (status == EFI_INVALID_PARAMETER)
+        {
+            continue;
+        }
+        if (status == EFI_SUCCESS)
+        {
+            break;
+        }
+        writeln("ExitBootServices: Error %x", status);
+        wait_key();
+        return EFI_SUCCESS;
+    }
+
+    build_page_tables();
+
+    jump_to_hulk();
+
+    return EFI_SUCCESS;
+}

src/hello/output.d

@@ -0,0 +1,122 @@
+import uefi;
+import hello;
+import core.stdc.stdarg;
+
+private size_t format_hex(CHAR16 * s, ulong v, bool ptr)
+{
+    string hex_chars = "0123456789ABCDEF";
+    bool print = ptr;
+    size_t si = 0u;
+    for (size_t i = 0u; i < 16u; i++)
+    {
+        if (ptr && (i == 8u))
+        {
+            s[si++] = '_';
+        }
+        ulong n = (v >> (60u - 4u * i)) & 0xFu;
+        if (n != 0u)
+        {
+            print = true;
+        }
+        if (print || (i == 15u))
+        {
+            s[si++] = hex_chars[n];
+        }
+    }
+    return si;
+}
+
+private size_t format_dec(CHAR16 * s, ulong v)
+{
+    string dec_chars = "0123456789";
+    bool print;
+    char[20] buf;
+    size_t buf_i;
+    while ((buf_i == 0u) || (v != 0u))
+    {
+        ulong n = v % 10u;
+        buf[buf_i++] = dec_chars[n];
+        v /= 10u;
+    }
+    for (size_t si = 0u; si < buf_i; si++)
+    {
+        s[si] = buf[buf_i - si - 1u];
+    }
+    return buf_i;
+}
+
+void write(string s, va_list args)
+{
+    __gshared static CHAR16[256] s16;
+    size_t i = 0u;
+    bool escape = false;
+    foreach (char c; s)
+    {
+        if (escape)
+        {
+            if (c == '%')
+            {
+                s16[i++] = '%';
+            }
+            else if (c == 'x')
+            {
+                ulong v;
+                va_arg(args, v);
+                i += format_hex(&s16[i], v, false);
+            }
+            else if (c == 'p')
+            {
+                ulong v;
+                va_arg(args, v);
+                i += format_hex(&s16[i], v, true);
+            }
+            else if (c == 'S')
+            {
+                const(CHAR16) * s2;
+                va_arg(args, s2);
+                for (size_t s2_i = 0u; s2[s2_i] != 0; s2_i++)
+                {
+                    s16[i++] = s2[s2_i];
+                }
+            }
+            else if (c == 'u')
+            {
+                ulong v;
+                va_arg(args, v);
+                i += format_dec(&s16[i], v);
+            }
+            else
+            {
+                s16[i++] = c;
+            }
+            escape = false;
+        }
+        else if (c == '%')
+        {
+            escape = true;
+        }
+        else
+        {
+            s16[i++] = c;
+        }
+    }
+    s16[i++] = 0u;
+    st.ConOut.OutputString(st.ConOut, &s16[0]);
+}
+
+extern (C) void write(string s, ...)
+{
+    va_list args;
+    va_start(args, s);
+    write(s, args);
+    va_end(args);
+}
+
+extern (C) void writeln(string s, ...)
+{
+    va_list args;
+    va_start(args, s);
+    write(s, args);
+    write("\r\n", args);
+    va_end(args);
+}

src/hello/scratch.d

@@ -0,0 +1,19 @@
+__gshared ubyte[512 * 1024] scratch;
+__gshared size_t scratch_used;
+
+size_t scratch_free()
+{
+    return scratch.sizeof - scratch_used;
+}
+
+ubyte * scratch_current()
+{
+    return &scratch[scratch_used];
+}
+
+ubyte * scratch_alloc(size_t n = 1)
+{
+    ubyte * address = &scratch[scratch_used];
+    scratch_used += 4096u * n;
+    return address;
+}

src/hulk/hulk.d

@@ -0,0 +1,16 @@
+import hulk.bootinfo;
+import hos.memory;
+import ldc.attributes;
+
+@(ldc.attributes.section(".hulk_start"))
+extern(C) void hulk_start(BootInfo * bootinfo)
+{
+    for (size_t y = 100u; y < 120u; y++)
+    {
+        memset32(&bootinfo.fb.buffer[y * bootinfo.fb.stride + 20u], 0xFF8800u, 20u);
+    }
+
+    for (;;)
+    {
+    }
+}

src/hulk/hulk.ld

@@ -0,0 +1,33 @@
+ENTRY(hulk_start)
+
+SECTIONS
+{
+    . = 0x0000800000000000;
+    _hulk_mem_start = .;
+
+    .text BLOCK(4K) : ALIGN(4K)
+    {
+        *(.hulk_start)
+        *(.text)
+    }
+
+    .rodata BLOCK(4K) : ALIGN(4K)
+    {
+        *(.rodata)
+    }
+
+    .data BLOCK(4K) : ALIGN(4K)
+    {
+        *(.data)
+    }
+
+    .bss BLOCK(4K) : ALIGN(4K)
+    {
+        *(COMMON)
+        *(.bss)
+    }
+
+    . = ALIGN(4K);
+
+    _hulk_mem_end = .;
+}

src/hulk/hulk/bootinfo.d

@@ -0,0 +1,22 @@
+struct BootInfo
+{
+    struct MemoryRegion
+    {
+        ulong base;
+        size_t size;
+    }
+    struct Framebuffer
+    {
+        uint * buffer;
+        uint width;
+        uint height;
+        uint stride;
+        uint format;
+    }
+
+    Framebuffer fb;
+    MemoryRegion[500] memory_map;
+    size_t memory_map_count;
+}
+
+enum ulong HULK_VIRTUAL_START = 0x0000_8000_0000_0000u;

x86_64-elf-gcc.rb

@@ -0,0 +1,76 @@
+project_name "x86_64-elf-gcc"
+binutils_version = "2.35"
+binutils_checksum = "1b11659fb49e20e18db460d44485f09442c8c56d5df165de9461eb09c8302f85"
+gcc_version = "10.2.0"
+gcc_checksum = "b8dd4368bb9c7f0b98188317ee0254dd8cc99d1e3a18d0ff146c855fe16c1d8c"
+install_path = File.expand_path("x86_64-elf-gcc")
+target = "x86_64-elf"
+path_prepend "#{install_path}/bin"
+
+configure do
+  check_c_compiler "gcc"
+  check_program "make"
+  check_program "bison"
+  check_program "flex"
+  check_program "texi2any", on_fail: "Install the texinfo package"
+  check_program "wget"
+  check_lib "gmp", on_fail: "Install the libgmp-dev package"
+  check_lib "mpc", on_fail: "Install the libmpc-dev package"
+  check_lib "mpfr", on_fail: "Install the libmpfr-dev package"
+end
+
+default do
+  unless Dir.exist?(install_path)
+    # Download archives.
+    download "https://ftp.gnu.org/gnu/binutils/binutils-#{binutils_version}.tar.xz",
+      "#{build_dir}/binutils-#{binutils_version}.tar.xz",
+      sha256sum: binutils_checksum
+
+    download "https://ftp.gnu.org/gnu/gcc/gcc-#{gcc_version}/gcc-#{gcc_version}.tar.xz",
+      "#{build_dir}/gcc-#{gcc_version}.tar.xz",
+      sha256sum: gcc_checksum
+
+    # Extract archives.
+    sh "tar", "xJf", "binutils-#{binutils_version}.tar.xz",
+      chdir: build_dir
+
+    sh "tar", "xJf", "gcc-#{gcc_version}.tar.xz",
+      chdir: build_dir
+
+    # Build binutils.
+    rm_rf "#{build_dir}/build-binutils"
+    mkdir_p "#{build_dir}/build-binutils"
+    cd "#{build_dir}/build-binutils" do
+      sh %W[../binutils-#{binutils_version}/configure
+        --target=#{target} --prefix=#{install_path} --with-sysroot --disable-nls
+        --disable-werror]
+      sh "make"
+      sh "make install"
+    end
+
+    # Build gcc.
+    rm_rf "#{build_dir}/build-gcc"
+    mkdir_p "#{build_dir}/build-gcc"
+    cd "#{build_dir}/build-gcc" do
+      sh %W[../gcc-#{gcc_version}/configure
+        --target=#{target} --prefix=#{install_path} --disable-nls
+        --enable-languages=c --without-headers]
+      sh "make all-gcc"
+      sh "make all-target-libgcc"
+      sh "make install-gcc"
+      sh "make install-target-libgcc"
+    end
+
+    # Remove archives and build directories if everything succeeded.
+    rm_f "#{build_dir}/binutils-#{binutils_version}.tar.xz"
+    rm_rf "#{build_dir}/binutils-#{binutils_version}"
+    rm_rf "#{build_dir}/build-binutils"
+    rm_f "#{build_dir}/gcc-#{gcc_version}.tar.xz"
+    rm_rf "#{build_dir}/gcc-#{gcc_version}"
+    rm_rf "#{build_dir}/build-gcc"
+  end
+end
+
+distclean do
+  rm_rf install_path
+end