Compare commits
No commits in common. "dev" and "master" have entirely different histories.
2
.gitignore
vendored
2
.gitignore
vendored
@ -1,3 +1,3 @@
|
||||
.rscons*
|
||||
/x86_64-elf-gcc/
|
||||
/i686-elf-gcc/
|
||||
/build/
|
||||
|
||||
3
.gitmodules
vendored
3
.gitmodules
vendored
@ -1,3 +0,0 @@
|
||||
[submodule "uefi-d"]
|
||||
path = uefi-d
|
||||
url = git://github.com/kubasz/uefi-d
|
||||
71
README.md
71
README.md
@ -1,71 +0,0 @@
|
||||
# HOS System Requirements
|
||||
|
||||
HOS requires:
|
||||
|
||||
* A 64-bit CPU.
|
||||
* A UEFI system.
|
||||
* 128MB of RAM.
|
||||
|
||||
# Building HOS
|
||||
|
||||
From the top level of the repository, run:
|
||||
|
||||
./rscons
|
||||
|
||||
If you get errors about missing packages, install the packages and then re-run
|
||||
the build command.
|
||||
|
||||
# Running HOS
|
||||
|
||||
## Physical Machine
|
||||
|
||||
To install HOS to an EFI partition, follow these steps:
|
||||
|
||||
1. Copy build/hello/HOS.EFI to EFI partition EFI/HOS.EFI. For example, from Linux:
|
||||
|
||||
sudo cp build/hello/HOS.EFI /boot/efi/EFI/HOS.EFI
|
||||
|
||||
2. Register EFI loader for HOS (one time only) with command:
|
||||
|
||||
efibootmgr -c -d /dev/nvme1n1 -p 2 -l '\EFI\HOS.EFI' -L HOS
|
||||
|
||||
(Update the -d device parameter and -p partition parameter as appropriate)
|
||||
|
||||
3. Set boot order to desired boot order. Exact order will be system dependent. Example:
|
||||
|
||||
efibootmgr -o 2,0,6,5
|
||||
|
||||
At this point you should be able to boot HOS from your EFI boot selection menu.
|
||||
If you use GRUB, you can optionally create a GRUB boot entry to load HOS.EFI
|
||||
with an entry like this:
|
||||
|
||||
menuentry 'HOS' {
|
||||
insmod part_gpt
|
||||
insmod chain
|
||||
set root='(hd0,gpt1)'
|
||||
chainloader /EFI/HOS.EFI
|
||||
}
|
||||
|
||||
Just update the root setting for the correction location to your system's EFI
|
||||
partition.
|
||||
|
||||
## VirtualBox
|
||||
|
||||
To create a VM in VirtualBox:
|
||||
|
||||
1. Build HOS ("./rscons").
|
||||
2. In VirtualBox, select Machine -> New.
|
||||
3. Set name to HOS.
|
||||
4. Set Type to Other.
|
||||
5. Set Version to Other/Unknown (64-bit).
|
||||
6. Click Next.
|
||||
7. Set memory size to 512 MB.
|
||||
8. Click Next.
|
||||
9. Select Do not add a virtual hard disk.
|
||||
10. Click Create.
|
||||
11. From the HOS repository, create a VirtualBox VMDK image with "./rscons mk-vmdk".
|
||||
12. Move the HOS.vmdk file generated to the HOS VirtualBox folder.
|
||||
13. In VirtualBox Manager, open HOS VM settings.
|
||||
14. Under System, check the Enable EFI checkbox.
|
||||
15. Under Storage, add a hard disk and browse to select the HOS.vmdk file.
|
||||
16. To run HOS, either start the VM through VirtualBox or with "./rscons run-vb".
|
||||
273
Rsconscript
273
Rsconscript
@ -1,86 +1,104 @@
|
||||
require "tmpdir"
|
||||
|
||||
project_name "HOS"
|
||||
path_prepend "x86_64-elf-gcc/bin"
|
||||
path_prepend "i686-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
|
||||
rscons "i686-elf-gcc.rb", "-b", "#{build_dir}/i686-elf-gcc"
|
||||
check_c_compiler "i686-elf-gcc"
|
||||
check_program "genext2fs"
|
||||
check_program "grub-mkstandalone"
|
||||
check_program "mformat", on_fail: "Install the mtools package"
|
||||
check_program "parted"
|
||||
check_program "xorriso"
|
||||
check_cfg package: "freetype2", on_fail: "Install libfreetype-dev", use: "freetype"
|
||||
sh %w[git submodule update --init]
|
||||
end
|
||||
|
||||
# Kernel default font size.
|
||||
KFONT_SIZE = 18
|
||||
require "tmpdir"
|
||||
|
||||
# One kilobyte.
|
||||
KB = 1024
|
||||
# EFI (w/ GRUB) partition size (MiB)
|
||||
EFI_PART_SIZE = 8
|
||||
# HOS partition size (MiB)
|
||||
HOS_PART_SIZE = 4
|
||||
# Kernel default font size
|
||||
KFONT_SIZE = 15
|
||||
|
||||
# One megabyte.
|
||||
MB = 1024 * 1024
|
||||
|
||||
class HulkBinObj < Builder
|
||||
class BiosImage < Builder
|
||||
def run(options)
|
||||
FileUtils.mkdir_p(File.dirname(@target))
|
||||
File.write(@target, <<EOF)
|
||||
.section ".rodata"
|
||||
.balign 4096
|
||||
.global _hulk_bin_start
|
||||
_hulk_bin_start:
|
||||
.incbin "#{@sources.first}"
|
||||
.balign 4096
|
||||
.global _hulk_bin_end
|
||||
_hulk_bin_end:
|
||||
unless @cache.up_to_date?(@target, nil, @sources, @env)
|
||||
print_run_message("Generating BIOS boot image #{@target}", nil)
|
||||
Dir.mktmpdir do |tmpdir|
|
||||
# Create iso directory.
|
||||
FileUtils.mkdir_p("#{tmpdir}/iso/boot/grub")
|
||||
File.open("#{tmpdir}/iso/boot/grub/grub.cfg", "wb") do |fh|
|
||||
fh.write(<<EOF)
|
||||
set default="0"
|
||||
set timeout=1
|
||||
menuentry "HOS" {
|
||||
insmod multiboot2
|
||||
multiboot2 /hos.elf
|
||||
}
|
||||
EOF
|
||||
unless @cache.up_to_date?(@target, nil, @sources, @env)
|
||||
print_run_message("Creating HULK binary object <target>#{@target}<reset>", nil)
|
||||
end
|
||||
@sources.each do |source|
|
||||
FileUtils.cp(source, "#{tmpdir}/iso")
|
||||
end
|
||||
# Build bootable GRUB image.
|
||||
system(*%W[grub-mkrescue -o #{@target} #{tmpdir}/iso], err: "#{@env.build_root}/grub-mkrescue.log")
|
||||
end
|
||||
@cache.register_build(@target, nil, @sources, @env)
|
||||
end
|
||||
true
|
||||
end
|
||||
end
|
||||
|
||||
# Create a GPT disk image with an EFI partition containing the EFI image.
|
||||
class Image < Builder
|
||||
class EfiImage < Builder
|
||||
def run(options)
|
||||
unless @cache.up_to_date?(@target, nil, @sources, @env)
|
||||
print_run_message("Creating disk image <target>#{@target}<reset>", nil)
|
||||
efi_image_size = File.stat(@sources.first).size
|
||||
efi_image_size_mb = (efi_image_size + MB - 1) / MB
|
||||
partition_size_mb = efi_image_size_mb + 1
|
||||
empty_mb = "\0".b * MB
|
||||
File.binwrite(@target, empty_mb * partition_size_mb)
|
||||
system(*%W[mformat -i #{@target} ::])
|
||||
system(*%W[mmd -i #{@target} ::/EFI])
|
||||
system(*%W[mmd -i #{@target} ::/EFI/BOOT])
|
||||
system(*%W[mcopy -i #{@target} #{@sources.first} ::/EFI/BOOT/BOOTX64.EFI])
|
||||
partition_contents = File.binread(@target)
|
||||
disk_image = empty_mb + partition_contents + empty_mb
|
||||
File.binwrite(@target, disk_image)
|
||||
system(*%W[parted --script #{@target} mklabel gpt mkpart HOS fat32 1MiB #{partition_size_mb + 1}MiB])
|
||||
print_run_message("Generating EFI boot image #{@target}", nil)
|
||||
Dir.mktmpdir do |tmpdir|
|
||||
# Build a standalone GRUB.
|
||||
File.open("#{tmpdir}/grub.cfg", "wb") do |fh|
|
||||
fh.write(<<EOF)
|
||||
insmod part_gpt
|
||||
configfile (hd0,gpt2)/grub.cfg
|
||||
EOF
|
||||
end
|
||||
system(*%W[grub-mkstandalone -O x86_64-efi -o #{tmpdir}/BOOTX64.EFI boot/grub/grub.cfg=#{tmpdir}/grub.cfg])
|
||||
# Create EFI partition.
|
||||
system(*%W[dd if=/dev/zero of=#{tmpdir}/efi.part bs=1M count=#{EFI_PART_SIZE}], err: "/dev/null")
|
||||
system(*%W[mformat -i #{tmpdir}/efi.part ::])
|
||||
system(*%W[mmd -i #{tmpdir}/efi.part ::/EFI])
|
||||
system(*%W[mmd -i #{tmpdir}/efi.part ::/EFI/BOOT])
|
||||
system(*%W[mcopy -i #{tmpdir}/efi.part #{tmpdir}/BOOTX64.EFI ::/EFI/BOOT])
|
||||
# Create ext2 HOS partition.
|
||||
FileUtils.mkdir_p("#{tmpdir}/ext2")
|
||||
@sources.each do |source|
|
||||
FileUtils.cp(source, "#{tmpdir}/ext2")
|
||||
end
|
||||
File.open("#{tmpdir}/ext2/grub.cfg", "wb") do |fh|
|
||||
fh.write(<<EOF)
|
||||
set default="0"
|
||||
set timeout=1
|
||||
menuentry "HOS" {
|
||||
insmod part_gpt
|
||||
insmod multiboot2
|
||||
set root=(hd0,gpt2)
|
||||
multiboot2 /hos.elf
|
||||
}
|
||||
EOF
|
||||
end
|
||||
system(*%W[genext2fs -b #{HOS_PART_SIZE * 1024} -d #{tmpdir}/ext2 #{tmpdir}/ext2.part])
|
||||
# Create full disk image.
|
||||
system(*%W[dd if=/dev/zero of=#{@target} bs=1M count=#{EFI_PART_SIZE + HOS_PART_SIZE + 2}], err: "/dev/null")
|
||||
system(*%W[parted -s #{@target} mklabel gpt])
|
||||
system(*%W[parted -s #{@target} mkpart efi 1MiB #{EFI_PART_SIZE + 1}MiB])
|
||||
system(*%W[parted -s #{@target} mkpart hos #{EFI_PART_SIZE + 1}MiB #{EFI_PART_SIZE + HOS_PART_SIZE + 1}MiB])
|
||||
system(*%W[dd if=#{tmpdir}/efi.part of=#{@target} bs=1M seek=1 conv=notrunc], err: "/dev/null")
|
||||
system(*%W[dd if=#{tmpdir}/ext2.part of=#{@target} bs=1M seek=#{1 + EFI_PART_SIZE} conv=notrunc], err: "/dev/null")
|
||||
end
|
||||
@cache.register_build(@target, nil, @sources, @env)
|
||||
end
|
||||
true
|
||||
end
|
||||
end
|
||||
|
||||
class CheckThreadLocal < Builder
|
||||
def run(options)
|
||||
map_file = File.binread(@sources.first)
|
||||
if map_file =~ /\.(tdata|tbss)\b/
|
||||
$stderr.puts "Error: found thread-local data in #{@sources.first}"
|
||||
false
|
||||
else
|
||||
true
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
class FontGen < Builder
|
||||
def run(options)
|
||||
if @command
|
||||
@ -94,108 +112,55 @@ class FontGen < Builder
|
||||
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.add_builder(FontGen)
|
||||
env.add_builder(CheckThreadLocal)
|
||||
env.FontGen("^/src/hulk/kfont.d", "font/Hack-Regular.ttf",
|
||||
"fontgen" => fontgen_env.expand("^/fontgen"))
|
||||
env["sources"] = glob("src/hulk/**/*.d")
|
||||
env["sources"] << "^/src/hulk/kfont.d"
|
||||
cpu_attrs = %w[
|
||||
-avx
|
||||
-avx2
|
||||
-avx512bf16
|
||||
-avx512bitalg
|
||||
-avx512bw
|
||||
-avx512cd
|
||||
-avx512dq
|
||||
-avx512er
|
||||
-avx512f
|
||||
-avx512ifma
|
||||
-avx512pf
|
||||
-avx512vbmi
|
||||
-avx512vbmi2
|
||||
-avx512vl
|
||||
-avx512vnni
|
||||
-avx512vp2intersect
|
||||
-avx512vpopcntdq
|
||||
-sse
|
||||
-sse-unaligned-mem
|
||||
-sse2
|
||||
-sse3
|
||||
-sse4.1
|
||||
-sse4.2
|
||||
-sse4a
|
||||
-ssse3
|
||||
]
|
||||
env["DFLAGS"] += %W[-mtriple=x86_64-unknown-elf -mattr=#{cpu_attrs.join(",")} --betterC -release -O3 --wi --enable-cross-module-inlining -code-model=large]
|
||||
env["D_IMPORT_PATH"] += %w[src]
|
||||
env["D_IMPORT_PATH"] << env.expand("^/src")
|
||||
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.produces("^/hulk.elf", "^/hulk.elf.map")
|
||||
env.CheckThreadLocal(:hulk_map_check, "^/hulk.elf.map")
|
||||
env.depends("^/hulk.elf", "src/hulk/hulk.ld")
|
||||
env["SIZE"] = "x86_64-elf-size"
|
||||
env.Size("^/hulk.size", "^/hulk.elf")
|
||||
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:")
|
||||
env.add_build_hook do |builder|
|
||||
if builder.target.end_with?(".o")
|
||||
env.Disassemble("#{builder.target}.txt", builder.target)
|
||||
class Size < Builder
|
||||
def run(options)
|
||||
if @command
|
||||
finalize_command
|
||||
else
|
||||
@vars["_SOURCES"] = @sources
|
||||
@vars["_TARGET"] = @target
|
||||
command = @env.build_command(%w[${SIZE} ${_SOURCES}], @vars)
|
||||
standard_command("Size <target>#{@target}<reset>", command, stdout: @target)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
hello_env = env "hello", use: %w[ldc2 x86_64-w64-mingw32-gcc] do |env|
|
||||
env.add_builder(Image)
|
||||
env.add_builder(CheckThreadLocal)
|
||||
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.Object("^/hulk_bin.o", "^/hulk_bin.S")
|
||||
env.depends("^/hulk_bin.o", hulk_env.expand("^/hulk.bin"))
|
||||
env["sources"] << "^/hulk_bin.o"
|
||||
env["DFLAGS"] += %w[-mtriple=x86_64-unknown-windows-coff --betterC -release -O3 --wi --enable-cross-module-inlining]
|
||||
env["D_IMPORT_PATH"] += %w[src uefi-d/source]
|
||||
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("^/HOS.EFI", "${sources}")
|
||||
env.produces("^/HOS.EFI", "^/HOS.EFI.map")
|
||||
env.CheckThreadLocal(:hos_map_check, "^/HOS.EFI.map")
|
||||
env["SIZE"] = "x86_64-w64-mingw32-size"
|
||||
env.Size("^/HOS.size", "^/HOS.EFI")
|
||||
env.Disassemble("^/HOS.txt", "^/HOS.EFI")
|
||||
env.Image("^/HOS.img", "^/HOS.EFI")
|
||||
# FontGen Environment
|
||||
fontgen_env = env "fontgen", use: "freetype" do |env|
|
||||
env["CC"] = "gcc"
|
||||
env.Program("^/fontgen.bin", glob("fontgen/**/*.c"))
|
||||
end
|
||||
|
||||
# Kernel Environment
|
||||
kernel_env = env "kernel" do |env|
|
||||
env.add_builder(EfiImage)
|
||||
env.add_builder(BiosImage)
|
||||
env.add_builder(FontGen)
|
||||
env.add_builder(Size)
|
||||
env["OBJDUMP"] = "i686-elf-objdump"
|
||||
env["SIZE"] = "i686-elf-size"
|
||||
env["CCFLAGS"] += %w[-ffreestanding -Wall -O2]
|
||||
env["LDFLAGS"] += %w[-ffreestanding -nostdlib -T src/link.ld]
|
||||
env["LDFLAGS"] += %W[-Wl,-Map,${_TARGET}.map]
|
||||
env["LIBS"] += %w[gcc]
|
||||
env.FontGen("^/kfont/kfont.c", "font/Hack-Regular.ttf",
|
||||
"fontgen" => fontgen_env.expand("^/fontgen.bin"))
|
||||
env.barrier
|
||||
env["CPPPATH"] += ["#{env.build_root}/kfont"]
|
||||
env.Program("^/hos.elf", glob("src/**/*.{S,c}") + ["^/kfont/kfont.c"])
|
||||
env.depends("#{env.build_root}/hos.elf", "src/link.ld")
|
||||
env.Disassemble("^/hos.elf.txt", "^/hos.elf")
|
||||
env.Size("^/hos.elf.size", "^/hos.elf")
|
||||
env.EfiImage("^/hos-efi.img", %w[^/hos.elf])
|
||||
env.BiosImage("^/hos.img", %w[^/hos.elf])
|
||||
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 -cpu max -bios OVMF.fd -drive file=#{tmpdir}/HOS.img,format=raw -device qemu-xhci -device usb-tablet]
|
||||
end
|
||||
img = kernel_env.expand("^/hos.img")
|
||||
sh %W[qemu-system-x86_64 -hda #{img}]
|
||||
end
|
||||
|
||||
# See README.md for how to set up VirtualBox for HOS.
|
||||
task "mk-vmdk", desc: "Create VirtualBox VMDK virtual drive for HOS" do
|
||||
sh %W[VBoxManage internalcommands createrawvmdk -filename HOS.vmdk -rawdisk #{File.expand_path(hello_env.expand("^/HOS.img"))}]
|
||||
end
|
||||
|
||||
# See README.md for how to set up VirtualBox for HOS.
|
||||
task "run-vb", desc: "Run HOS in VirtualBox" do
|
||||
sh %W[VBoxManage startvm HOS]
|
||||
task "run-efi", desc: "Run HOS EFI in QEMU" do
|
||||
img = kernel_env.expand("^/hos-efi.img")
|
||||
sh %W[qemu-system-x86_64 -bios OVMF.fd -hda #{img}]
|
||||
end
|
||||
|
||||
@ -62,13 +62,52 @@ static void load_char(FT_Face face, int char_code)
|
||||
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, " ");
|
||||
}
|
||||
fprintf(file, "0x%02xu,", bytes[i]);
|
||||
if ((i + 1) % 8 == 0)
|
||||
@ -86,50 +125,62 @@ static void generate_bytes(FILE * file, const uint8_t * bytes, int count)
|
||||
}
|
||||
}
|
||||
|
||||
static void generate(const char * d_file_name)
|
||||
static void generate(const char * c_file_name)
|
||||
{
|
||||
FILE * fh = fopen(d_file_name, "wb");
|
||||
fprintf(fh, "module hulk.kfont;\n");
|
||||
fprintf(fh, "struct CharInfo {\n");
|
||||
fprintf(fh, " uint width;\n");
|
||||
fprintf(fh, " uint height;\n");
|
||||
fprintf(fh, " int top;\n");
|
||||
fprintf(fh, " int left;\n");
|
||||
fprintf(fh, " const ubyte[] bitmap;\n");
|
||||
fprintf(fh, "};\n");
|
||||
fprintf(fh, "struct FontInfo {\n");
|
||||
fprintf(fh, " uint line_height;\n");
|
||||
fprintf(fh, " uint advance;\n");
|
||||
fprintf(fh, " int baseline_offset;\n");
|
||||
fprintf(fh, " const CharInfo[] chars;\n");
|
||||
fprintf(fh, "};\n");
|
||||
fprintf(fh, "__gshared const FontInfo kfont = {\n");
|
||||
fprintf(fh, " %du,\n", line_height);
|
||||
fprintf(fh, " %du,\n", max_advance);
|
||||
fprintf(fh, " %d,\n", baseline_offset);
|
||||
fprintf(fh, " [\n");
|
||||
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++)
|
||||
{
|
||||
fprintf(fh, " CharInfo(\n");
|
||||
fprintf(fh, " %du,\n", char_infos[i].width);
|
||||
fprintf(fh, " %du,\n", char_infos[i].height);
|
||||
fprintf(fh, " %d,\n", char_infos[i].top);
|
||||
fprintf(fh, " %d,\n", char_infos[i].left);
|
||||
if (char_infos[i].width > 0)
|
||||
{
|
||||
fprintf(fh, " [\n");
|
||||
generate_bytes(fh, char_infos[i].bitmap, char_infos[i].width * char_infos[i].height);
|
||||
fprintf(fh, " ]\n");
|
||||
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(fh, " []\n");
|
||||
fprintf(c_file, " NULL,\n");
|
||||
}
|
||||
fprintf(fh, " ),\n");
|
||||
fprintf(c_file, "};\n\n");
|
||||
}
|
||||
fprintf(fh, " ],\n");
|
||||
fprintf(fh, "};\n");
|
||||
fclose(fh);
|
||||
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[])
|
||||
@ -1,10 +1,9 @@
|
||||
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"
|
||||
install_path = File.expand_path("i686-elf-gcc")
|
||||
target = "i686-elf"
|
||||
path_prepend "#{install_path}/bin"
|
||||
|
||||
configure do
|
||||
@ -54,7 +53,7 @@ default do
|
||||
cd "#{build_dir}/build-gcc" do
|
||||
sh %W[../gcc-#{gcc_version}/configure
|
||||
--target=#{target} --prefix=#{install_path} --disable-nls
|
||||
--enable-languages=c --without-headers]
|
||||
--enable-languages=c,c++ --without-headers]
|
||||
sh "make all-gcc"
|
||||
sh "make all-target-libgcc"
|
||||
sh "make install-gcc"
|
||||
18
src/boot.S
Normal file
18
src/boot.S
Normal file
@ -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
|
||||
116
src/fb.c
Normal file
116
src/fb.c
Normal file
@ -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;
|
||||
}
|
||||
}
|
||||
16
src/fb.h
Normal file
16
src/fb.h
Normal file
@ -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
|
||||
11
src/fb_text.c
Normal file
11
src/fb_text.c
Normal file
@ -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);
|
||||
}
|
||||
8
src/fb_text.h
Normal file
8
src/fb_text.h
Normal file
@ -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
|
||||
16
src/gdt.S
Normal file
16
src/gdt.S
Normal file
@ -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
|
||||
20
src/gdt.c
Normal file
20
src/gdt.c
Normal file
@ -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();
|
||||
}
|
||||
34
src/gdt.h
Normal file
34
src/gdt.h
Normal file
@ -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
|
||||
@ -1,181 +0,0 @@
|
||||
/**
|
||||
* HELLO console support.
|
||||
*/
|
||||
module hello.console;
|
||||
|
||||
import uefi;
|
||||
import hello.hello;
|
||||
import core.stdc.stdarg;
|
||||
|
||||
struct console
|
||||
{
|
||||
/**
|
||||
* Format a hexadecimal value to a string.
|
||||
*
|
||||
* @param s String buffer.
|
||||
* @param v Value to format.
|
||||
* @param ptr If true, always output all 16 digits, and separate the upper and
|
||||
* lower halves with an underscore.
|
||||
*/
|
||||
private static 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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Format a decimal value to a string.
|
||||
*
|
||||
* @param s String buffer.
|
||||
* @param v Value to format.
|
||||
*/
|
||||
private static 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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a string to the console.
|
||||
*
|
||||
* @param s Format string.
|
||||
* @param args Variable arguments structure.
|
||||
*/
|
||||
public static 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]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a string to the console.
|
||||
*
|
||||
* @param s Format string.
|
||||
*/
|
||||
public static extern (C) void write(string s, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, s);
|
||||
write(s, args);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a string to the console.
|
||||
*
|
||||
* @param s Format string.
|
||||
*/
|
||||
public static extern (C) void writeln(string s, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, s);
|
||||
write(s, args);
|
||||
write("\r\n", args);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a message to press any key and wait for a key to be pressed.
|
||||
*/
|
||||
public static 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)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear the console.
|
||||
*/
|
||||
public static void clear()
|
||||
{
|
||||
st.ConOut.ClearScreen(st.ConOut);
|
||||
}
|
||||
}
|
||||
@ -1,562 +0,0 @@
|
||||
/**
|
||||
* HELLO, the HOS EFI Lightweight LOader.
|
||||
*/
|
||||
module hello.hello;
|
||||
|
||||
import uefi;
|
||||
import hello.console;
|
||||
import hulk.bootinfo;
|
||||
import hulk.header;
|
||||
import hulk.pagetable;
|
||||
import hulk.cpu;
|
||||
import hulk.memory;
|
||||
import ldc.llvmasm;
|
||||
|
||||
__gshared EFI_SYSTEM_TABLE * st;
|
||||
/** HULK binary start address, 4KB-aligned. */
|
||||
extern extern(C) __gshared ubyte _hulk_bin_start;
|
||||
/** HULK binary end address, 4KB-aligned. */
|
||||
extern extern(C) __gshared ubyte _hulk_bin_end;
|
||||
private align(4096) __gshared ubyte[1024 * 1024] scratch_buffer;
|
||||
/** Index to the memory map region being used to allocate page tables. */
|
||||
private __gshared size_t memory_map_page_table_alloc_index;
|
||||
|
||||
private HulkHeader * hulk_header()
|
||||
{
|
||||
return cast(HulkHeader *)&_hulk_bin_start;
|
||||
}
|
||||
|
||||
private BootInfo * bootinfo()
|
||||
{
|
||||
return &hulk_header().bootinfo;
|
||||
}
|
||||
|
||||
private ulong hulk_bin_phys()
|
||||
{
|
||||
return cast(ulong)&_hulk_bin_start;
|
||||
}
|
||||
|
||||
private ulong hulk_bin_size()
|
||||
{
|
||||
return cast(ulong)&_hulk_bin_end - cast(ulong)&_hulk_bin_start;
|
||||
}
|
||||
|
||||
private ulong hulk_bss_size()
|
||||
{
|
||||
return cast(ulong)hulk_header().hulk_bss_size;
|
||||
}
|
||||
|
||||
private ulong hulk_stack_size()
|
||||
{
|
||||
return hulk_header().stack_size;
|
||||
}
|
||||
|
||||
private ulong hulk_virt_base_address()
|
||||
{
|
||||
return hulk_header().virt_base;
|
||||
}
|
||||
|
||||
private ulong hulk_virt_stack_top()
|
||||
{
|
||||
return hulk_header().virt_stack_top;
|
||||
}
|
||||
|
||||
private ulong hulk_virt_framebuffer_address()
|
||||
{
|
||||
return hulk_header().virt_fb_buffer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Detect if we're running in QEMU.
|
||||
*/
|
||||
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));
|
||||
}
|
||||
|
||||
/**
|
||||
* Set a graphics mode.
|
||||
*/
|
||||
private bool set_graphics_mode()
|
||||
{
|
||||
uint max_horizontal_resolution = in_qemu() ? 1920u : 0xFFFFFFFFu;
|
||||
UINTN buffer_size = scratch_buffer.sizeof;
|
||||
EFI_GUID gop_guid = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
|
||||
EFI_HANDLE * handles = cast(EFI_HANDLE *)&scratch_buffer[0];
|
||||
EFI_STATUS status = st.BootServices.LocateHandle(ByProtocol,
|
||||
&gop_guid, null, &buffer_size, handles);
|
||||
if (status != EFI_SUCCESS)
|
||||
{
|
||||
console.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)
|
||||
{
|
||||
console.writeln("HandleProtocol: error %x", status);
|
||||
return false;
|
||||
}
|
||||
if (gop_interface == null)
|
||||
{
|
||||
console.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)
|
||||
{
|
||||
console.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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Walk the EFI memory map and translate it to the HULK bootinfo format.
|
||||
*/
|
||||
private void get_memory_map(ulong * physical_address_limit, UINTN * memory_map_key)
|
||||
{
|
||||
immutable static ubyte[] efi_to_hulk_memory_map_type = [
|
||||
BootInfo.MemoryRegion.Type.Reserved, // EfiReservedMemoryType
|
||||
BootInfo.MemoryRegion.Type.Bootloader, // EfiLoaderCode
|
||||
BootInfo.MemoryRegion.Type.Bootloader, // EfiLoaderData
|
||||
BootInfo.MemoryRegion.Type.Bootloader, // EfiBootServicesCode
|
||||
BootInfo.MemoryRegion.Type.Bootloader, // EfiBootServicesData
|
||||
BootInfo.MemoryRegion.Type.Reserved, // EfiRuntimeServicesCode
|
||||
BootInfo.MemoryRegion.Type.Reserved, // EfiRuntimeServicesData
|
||||
BootInfo.MemoryRegion.Type.Conventional, // EfiConventionalMemory
|
||||
BootInfo.MemoryRegion.Type.Unusable, // EfiUnusableMemory
|
||||
BootInfo.MemoryRegion.Type.ACPIReclaim, // EfiACPIReclaimMemory
|
||||
BootInfo.MemoryRegion.Type.ACPINVS, // EfiACPIMemoryNVS
|
||||
BootInfo.MemoryRegion.Type.MemoryMappedIO, // EfiMemoryMappedIO
|
||||
BootInfo.MemoryRegion.Type.MemoryMappedIOPortSpace, // EfiMemoryMappedIOPortSpace
|
||||
BootInfo.MemoryRegion.Type.PalCode, // EfiPalCode
|
||||
];
|
||||
*physical_address_limit = 0u;
|
||||
UINTN memory_map_size = scratch_buffer.sizeof;
|
||||
UINTN descriptor_size;
|
||||
UINT32 descriptor_version;
|
||||
ubyte * scratch_base = cast(ubyte *)&scratch_buffer[0];
|
||||
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)
|
||||
{
|
||||
console.writeln("GetMemoryMap: Error %x", status);
|
||||
for (;;) {}
|
||||
}
|
||||
size_t n_entries = memory_map_size / descriptor_size;
|
||||
size_t count;
|
||||
bool found_bss;
|
||||
bool found_stack;
|
||||
bool found_fb_buffer1;
|
||||
const(size_t) fb_size = (bootinfo().fb.stride * bootinfo().fb.height * 4u + PAGE_SIZE - 1u) & ~(PAGE_SIZE - 1u);
|
||||
for (count = 0u; count < n_entries; count++)
|
||||
{
|
||||
if (count > bootinfo().memory_map.length)
|
||||
{
|
||||
console.writeln("Memory map too large");
|
||||
for (;;) {}
|
||||
}
|
||||
EFI_MEMORY_DESCRIPTOR * descriptor = cast(EFI_MEMORY_DESCRIPTOR *)&scratch_base[count * descriptor_size];
|
||||
ulong end_address = descriptor.PhysicalStart + descriptor.NumberOfPages * 4096u;
|
||||
if ((end_address > *physical_address_limit) &&
|
||||
((descriptor.Type == EfiLoaderCode) ||
|
||||
(descriptor.Type == EfiLoaderData) ||
|
||||
(descriptor.Type == EfiBootServicesCode) ||
|
||||
(descriptor.Type == EfiBootServicesData) ||
|
||||
(descriptor.Type == EfiRuntimeServicesCode) ||
|
||||
(descriptor.Type == EfiRuntimeServicesData) ||
|
||||
(descriptor.Type == EfiConventionalMemory)))
|
||||
{
|
||||
*physical_address_limit = end_address;
|
||||
}
|
||||
if (descriptor.Type >= efi_to_hulk_memory_map_type.length)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
bootinfo().memory_map[count].base = descriptor.PhysicalStart;
|
||||
bootinfo().memory_map[count].size = descriptor.NumberOfPages * 4096u;
|
||||
bootinfo().memory_map[count].type = efi_to_hulk_memory_map_type[descriptor.Type];
|
||||
if ((!found_bss) &&
|
||||
(descriptor.Type == EfiConventionalMemory) &&
|
||||
(bootinfo().memory_map[count].size >= hulk_bss_size()))
|
||||
{
|
||||
bootinfo().bss_phys = bootinfo().memory_map[count].base;
|
||||
bootinfo().memory_map[count].base += hulk_bss_size();
|
||||
bootinfo().memory_map[count].size -= hulk_bss_size();
|
||||
found_bss = true;
|
||||
}
|
||||
if ((!found_stack) &&
|
||||
(descriptor.Type == EfiConventionalMemory) &&
|
||||
(bootinfo().memory_map[count].size >= hulk_stack_size()))
|
||||
{
|
||||
bootinfo().stack_phys = bootinfo().memory_map[count].base;
|
||||
bootinfo().memory_map[count].base += hulk_stack_size();
|
||||
bootinfo().memory_map[count].size -= hulk_stack_size();
|
||||
found_stack = true;
|
||||
}
|
||||
if ((!found_fb_buffer1) &&
|
||||
(descriptor.Type == EfiConventionalMemory) &&
|
||||
(bootinfo().memory_map[count].size >= fb_size))
|
||||
{
|
||||
bootinfo().fb_buffer1_phys = bootinfo().memory_map[count].base;
|
||||
bootinfo().memory_map[count].base += fb_size;
|
||||
bootinfo().memory_map[count].size -= fb_size;
|
||||
found_fb_buffer1 = true;
|
||||
}
|
||||
}
|
||||
bootinfo().memory_map_count = count;
|
||||
if ((!found_bss) || (!found_stack) || (!found_fb_buffer1))
|
||||
{
|
||||
for (;;) {}
|
||||
}
|
||||
}
|
||||
|
||||
private void * alloc_pt_page()
|
||||
{
|
||||
BootInfo.MemoryRegion * regions = &bootinfo().memory_map[0];
|
||||
for (;;)
|
||||
{
|
||||
BootInfo.MemoryRegion * region = &bootinfo().memory_map[memory_map_page_table_alloc_index];
|
||||
if ((region.type == BootInfo.MemoryRegion.Type.Conventional) && (region.size >= PAGE_SIZE))
|
||||
{
|
||||
void * addr = cast(void *)region.base;
|
||||
region.base += PAGE_SIZE;
|
||||
region.size -= PAGE_SIZE;
|
||||
return addr;
|
||||
}
|
||||
memory_map_page_table_alloc_index++;
|
||||
if (memory_map_page_table_alloc_index >= bootinfo().memory_map_count)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Allocate a new page table.
|
||||
*/
|
||||
private PageTable * new_page_table()
|
||||
{
|
||||
PageTable * pt = cast(PageTable *)alloc_pt_page();
|
||||
if (pt == null)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
memset64(pt, 0u, 512);
|
||||
return pt;
|
||||
}
|
||||
|
||||
/**
|
||||
* Map a virtual address to a physical address using 4KB pages.
|
||||
*
|
||||
* @param source_page Source page address.
|
||||
* @param dest_page Destination page address.
|
||||
* @param pt_base Page table base address.
|
||||
*/
|
||||
private bool map4k(ulong source_page, ulong dest_page, PageTable * pt_base)
|
||||
{
|
||||
PageTable * pt = pt_base;
|
||||
for (size_t level = 0; level < 4u; level++)
|
||||
{
|
||||
PageTableEntry * ppte = pt.entry(source_page, level);
|
||||
PageTableEntry pte = *ppte;
|
||||
if (pte.present)
|
||||
{
|
||||
pt = pte.follow();
|
||||
}
|
||||
else
|
||||
{
|
||||
PageTable * next_pt;
|
||||
ulong addr;
|
||||
if (level < 3u)
|
||||
{
|
||||
next_pt = new_page_table();
|
||||
if (next_pt == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
addr = cast(ulong)next_pt;
|
||||
}
|
||||
else
|
||||
{
|
||||
addr = dest_page;
|
||||
}
|
||||
*ppte = PageTableEntry(addr, PT_WRITABLE | PT_PRESENT);
|
||||
pt = next_pt;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Map a virtual region to a physical region using 4KB pages.
|
||||
*
|
||||
* @param source Source address.
|
||||
* @param dest Destination address.
|
||||
* @param size Region size.
|
||||
* @param pt_base Page table base address.
|
||||
*/
|
||||
private bool map4kregion(ulong source, ulong dest, size_t size, PageTable * pt_base)
|
||||
{
|
||||
ulong end = source + size;
|
||||
while (source < end)
|
||||
{
|
||||
if (!map4k(source, dest, pt_base))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
source += 4096u;
|
||||
dest += 4096u;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Map a virtual address to a physical address using 2MB pages.
|
||||
*
|
||||
* @param source_page Source page address.
|
||||
* @param dest_page Destination page address.
|
||||
* @param pt_base Page table base address.
|
||||
*/
|
||||
private bool map2m(ulong source_page, ulong dest_page, PageTable * pt_base)
|
||||
{
|
||||
PageTable * pt = pt_base;
|
||||
for (size_t level = 0; level < 3u; level++)
|
||||
{
|
||||
PageTableEntry * ppte = pt.entry(source_page, level);
|
||||
PageTableEntry pte = *ppte;
|
||||
if (pte.present)
|
||||
{
|
||||
pt = pte.follow();
|
||||
}
|
||||
else
|
||||
{
|
||||
PageTable * next_pt;
|
||||
if (level < 2u)
|
||||
{
|
||||
next_pt = new_page_table();
|
||||
if (next_pt == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
*ppte = PageTableEntry(next_pt, PT_WRITABLE | PT_PRESENT);
|
||||
}
|
||||
else
|
||||
{
|
||||
*ppte = PageTableEntry(dest_page, PT_HUGE_PAGE | PT_WRITABLE | PT_PRESENT);
|
||||
}
|
||||
pt = next_pt;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Map HULK virtual addresses to physical kernel location.
|
||||
*
|
||||
* @param pt_base Page table base address.
|
||||
*/
|
||||
private bool map_hulk(PageTable * pt_base)
|
||||
{
|
||||
/* Map HULK bin region. */
|
||||
ulong virt = hulk_virt_base_address();
|
||||
if (!map4kregion(virt, hulk_bin_phys(), hulk_bin_size(), pt_base))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
/* Map HULK bss region. */
|
||||
virt += hulk_bin_size();
|
||||
if (!map4kregion(virt, bootinfo().bss_phys, hulk_bss_size(), pt_base))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
/* Map HULK stack. */
|
||||
virt = hulk_virt_stack_top() - hulk_stack_size();
|
||||
if (!map4kregion(virt, bootinfo().stack_phys, hulk_stack_size(), pt_base))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Build page tables in preparation to jump to HULK.
|
||||
*
|
||||
* @param physical_address_limit Maximum physical address to identity map.
|
||||
*/
|
||||
private bool build_page_tables(ulong physical_address_limit)
|
||||
{
|
||||
PageTable * pt_base = new_page_table();
|
||||
if (pt_base == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
/* Map physical RAM. */
|
||||
for (size_t addr = 0u; addr < physical_address_limit; addr += (2u * 1024u * 1024u))
|
||||
{
|
||||
if (!map2m(addr, addr, pt_base))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
/* Map any memory regions that are outside physical RAM. */
|
||||
for (size_t i = 0u; i < bootinfo().memory_map_count; i++)
|
||||
{
|
||||
ulong addr = bootinfo().memory_map[i].base;
|
||||
if (addr >= physical_address_limit)
|
||||
{
|
||||
if (!map4kregion(addr, addr, bootinfo().memory_map[i].size, pt_base))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Map graphics framebuffer. */
|
||||
ulong framebuffer_size = bootinfo().fb.height * bootinfo().fb.stride * 4u;
|
||||
ulong fb_phys = cast(ulong)bootinfo().fb.buffer;
|
||||
ulong fb_virt = hulk_virt_framebuffer_address();
|
||||
if (!map4kregion(fb_virt, fb_phys, framebuffer_size, pt_base))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
/* Map HULK regions. */
|
||||
if (!map_hulk(pt_base))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
/* Switch to the new page table. */
|
||||
write_cr3(cast(ulong)pt_base);
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Jump to HULK entry point.
|
||||
*/
|
||||
private void jump_to_hulk()
|
||||
{
|
||||
__asm(
|
||||
"jmpq *$0",
|
||||
"r,{rsp}",
|
||||
hulk_header().entry, hulk_virt_stack_top());
|
||||
}
|
||||
|
||||
/**
|
||||
* Find the ACPI XSDT.
|
||||
*
|
||||
* @return Whether it was found.
|
||||
*/
|
||||
private bool find_acpi_xsdt()
|
||||
{
|
||||
for (size_t i = 0u; i < st.NumberOfTableEntries; i++)
|
||||
{
|
||||
if ((st.ConfigurationTable[i].VendorGuid == EFI_ACPI_TABLE_GUID) ||
|
||||
(st.ConfigurationTable[i].VendorGuid == ACPI_TABLE_GUID))
|
||||
{
|
||||
enum ulong rsdp_magic = 0x20525450_20445352u;
|
||||
const(EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER) * rdsp = cast(const(EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER) *)st.ConfigurationTable[i].VendorTable;
|
||||
if (rdsp.Signature == rsdp_magic)
|
||||
{
|
||||
if (rdsp.Revision >= EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER_REVISION)
|
||||
{
|
||||
bootinfo().acpi_xsdt_phys = rdsp.XsdtAddress;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* EFI application entry point.
|
||||
*
|
||||
* @param image_handle EFI application handle.
|
||||
* @param st Pointer to EFI system table.
|
||||
*/
|
||||
extern (C) EFI_STATUS efi_main(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE * st)
|
||||
{
|
||||
.st = st;
|
||||
|
||||
console.clear();
|
||||
|
||||
console.writeln("Welcome to HELLO, HOS EFI Lightweight LOader, v0.1.0");
|
||||
console.writeln("Firmware vendor: '%S', version: 0x%x", st.FirmwareVendor, st.FirmwareVendor);
|
||||
|
||||
if (!find_acpi_xsdt())
|
||||
{
|
||||
console.writeln("Error: Could not locate ACPI XSDT");
|
||||
console.wait_key();
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
if (!set_graphics_mode())
|
||||
{
|
||||
console.wait_key();
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
ulong physical_address_limit;
|
||||
UINTN memory_map_key;
|
||||
for (;;)
|
||||
{
|
||||
get_memory_map(&physical_address_limit, &memory_map_key);
|
||||
|
||||
EFI_STATUS status = st.BootServices.ExitBootServices(image_handle, memory_map_key);
|
||||
if (status == EFI_INVALID_PARAMETER)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if (status == EFI_SUCCESS)
|
||||
{
|
||||
break;
|
||||
}
|
||||
console.writeln("ExitBootServices: Error %x", status);
|
||||
console.wait_key();
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
if (!build_page_tables(physical_address_limit))
|
||||
{
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
bootinfo().hulk_phys = hulk_bin_phys();
|
||||
|
||||
jump_to_hulk();
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
25
src/hos_main.c
Normal file
25
src/hos_main.c
Normal file
@ -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());
|
||||
}
|
||||
281
src/hos_printf.c
Normal file
281
src/hos_printf.c
Normal file
@ -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);
|
||||
}
|
||||
10
src/hos_printf.h
Normal file
10
src/hos_printf.h
Normal file
@ -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
|
||||
102
src/hulk/acpi.d
102
src/hulk/acpi.d
@ -1,102 +0,0 @@
|
||||
/**
|
||||
* ACPI (Advanced Configuration and Power Interface) functionality.
|
||||
*/
|
||||
module hulk.acpi;
|
||||
|
||||
import hulk.hurl;
|
||||
import hulk.klog;
|
||||
import hulk.memory;
|
||||
|
||||
struct acpi
|
||||
{
|
||||
enum uint APIC_SIGNATURE = 0x43495041u;
|
||||
enum uint XSDT_SIGNATURE = 0x54445358u;
|
||||
|
||||
static struct XsdtHeader
|
||||
{
|
||||
uint signature;
|
||||
uint length;
|
||||
ubyte revision;
|
||||
ubyte checksum;
|
||||
char[6] oemid;
|
||||
ulong oemtableid;
|
||||
uint oem_revision;
|
||||
uint creator_id;
|
||||
uint creator_revision;
|
||||
}
|
||||
|
||||
static struct Xsdt
|
||||
{
|
||||
XsdtHeader header;
|
||||
uint _pad;
|
||||
ulong[0] tables;
|
||||
}
|
||||
|
||||
static struct MadtHeader
|
||||
{
|
||||
uint signature;
|
||||
uint length;
|
||||
ubyte revision;
|
||||
ubyte checksum;
|
||||
char[6] oemid;
|
||||
ulong oemtableid;
|
||||
uint oem_revision;
|
||||
uint creator_id;
|
||||
uint creator_revision;
|
||||
uint local_apic_address;
|
||||
uint flags;
|
||||
}
|
||||
|
||||
static struct MadtEntry
|
||||
{
|
||||
ubyte type;
|
||||
ubyte length;
|
||||
}
|
||||
|
||||
public static __gshared ulong apic_address;
|
||||
|
||||
public static void initialize(ulong acpi_xsdt_phys)
|
||||
{
|
||||
/* Map the XSDT header. */
|
||||
hurl.identity_map_range(acpi_xsdt_phys, Xsdt.sizeof, 0u);
|
||||
const(Xsdt) * xsdt = cast(const(Xsdt) *)acpi_xsdt_phys;
|
||||
if (xsdt.header.signature != XSDT_SIGNATURE)
|
||||
{
|
||||
klog.writef("XSDT signature invalid\n");
|
||||
return;
|
||||
}
|
||||
/* Map the entire XSDT. */
|
||||
hurl.identity_map_range(acpi_xsdt_phys, xsdt.header.length, 0u);
|
||||
size_t n_entries = (xsdt.header.length - xsdt.header.sizeof) / xsdt.tables[0].sizeof;
|
||||
for (size_t i = 0u; i < n_entries; i++)
|
||||
{
|
||||
ulong address = xsdt.tables[i];
|
||||
hurl.identity_map_range(address, 4u, 0u);
|
||||
uint signature = *cast(const(uint) *)address;
|
||||
if (signature == APIC_SIGNATURE)
|
||||
{
|
||||
parse_apic_table(address);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static parse_apic_table(ulong address)
|
||||
{
|
||||
const(MadtHeader) * madt_header = cast(const(MadtHeader) *)address;
|
||||
hurl.identity_map_range(address, madt_header.length, 0u);
|
||||
apic_address = madt_header.local_apic_address;
|
||||
klog.writefln("Found 32-bit APIC address: 0x%x", apic_address);
|
||||
const(void) * madt_end = cast(const(void) *)(address + madt_header.length);
|
||||
const(MadtEntry) * madt_entry = cast(const(MadtEntry) *)(address + 0x2Cu);
|
||||
while (madt_entry < madt_end)
|
||||
{
|
||||
madt_entry = cast(const(MadtEntry) *)(cast(size_t)madt_entry + madt_entry.length);
|
||||
if (madt_entry.type == 5u)
|
||||
{
|
||||
/* Found a 64-bit Local APIC Address Override entry. */
|
||||
memcpy(cast(void *)&apic_address, cast(const(void) *)madt_entry + 4u, 8u);
|
||||
klog.writefln("Found 64-bit APIC address: 0x%x", apic_address);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
104
src/hulk/apic.d
104
src/hulk/apic.d
@ -1,104 +0,0 @@
|
||||
/**
|
||||
* APIC (Advanced Programmable Interrupt Controller) functionality.
|
||||
*/
|
||||
module hulk.apic;
|
||||
|
||||
import hulk.klog;
|
||||
import hulk.hurl;
|
||||
import hulk.acpi;
|
||||
import hulk.idt;
|
||||
|
||||
struct apic
|
||||
{
|
||||
private enum uint PERIODIC_MODE = 0x2_0000u;
|
||||
|
||||
static struct ApicRegister
|
||||
{
|
||||
public uint value;
|
||||
alias value this;
|
||||
|
||||
private ubyte[12] _padding;
|
||||
}
|
||||
|
||||
static struct ApicRegisters
|
||||
{
|
||||
ApicRegister[2] _reserved0;
|
||||
ApicRegister lapic_id;
|
||||
ApicRegister lapic_version;
|
||||
ApicRegister[4] _reserved1;
|
||||
ApicRegister task_priority;
|
||||
ApicRegister arbitration_priority;
|
||||
ApicRegister processor_priority;
|
||||
ApicRegister eoi;
|
||||
ApicRegister remote_read;
|
||||
ApicRegister logical_destination;
|
||||
ApicRegister destination_format;
|
||||
ApicRegister spurious_interrupt_vector;
|
||||
ApicRegister[8] in_service;
|
||||
ApicRegister[8] trigger_mode;
|
||||
ApicRegister[8] interrupt_request;
|
||||
ApicRegister error_status;
|
||||
ApicRegister[6] _reserved2;
|
||||
ApicRegister lvt_cmci;
|
||||
ApicRegister[2] interrupt_command;
|
||||
ApicRegister lvt_timer;
|
||||
ApicRegister lvt_thermal_sensor;
|
||||
ApicRegister lvt_performance_monitoring_counters;
|
||||
ApicRegister[2] lvt_lint;
|
||||
ApicRegister lvt_error;
|
||||
ApicRegister initial_count;
|
||||
ApicRegister current_count;
|
||||
ApicRegister[4] _reserved3;
|
||||
ApicRegister divide_configuration;
|
||||
}
|
||||
|
||||
static struct IoApicRegisters
|
||||
{
|
||||
ApicRegister address;
|
||||
ApicRegister data;
|
||||
}
|
||||
|
||||
private static __gshared ApicRegisters * apic_registers;
|
||||
private static __gshared IoApicRegisters * io_apic_registers;
|
||||
|
||||
public static void initialize()
|
||||
{
|
||||
apic_registers = cast(ApicRegisters *)acpi.apic_address;
|
||||
io_apic_registers = cast(IoApicRegisters *)0xFEC0_0000u;
|
||||
hurl.map(cast(ulong)apic_registers, cast(ulong)apic_registers,
|
||||
PT_WRITABLE | PT_WRITE_THROUGH | PT_DISABLE_CACHE | PT_NO_EXECUTE);
|
||||
hurl.map(cast(ulong)io_apic_registers, cast(ulong)io_apic_registers,
|
||||
PT_WRITABLE | PT_WRITE_THROUGH | PT_DISABLE_CACHE | PT_NO_EXECUTE);
|
||||
klog.writefln("LAPIC ID: 0x%08x", apic_registers.lapic_id.value);
|
||||
klog.writefln("LAPIC version: 0x%08x", apic_registers.lapic_version.value);
|
||||
/* Enable local APIC to receive interrupts and set spurious interrupt
|
||||
* vector to 0xFF. */
|
||||
apic_registers.spurious_interrupt_vector.value = 0x1FFu;
|
||||
// apic_registers.lvt_timer.value = idt.INT_LAPIC_TIMER | PERIODIC_MODE;
|
||||
apic_registers.lvt_timer.value = idt.INT_LAPIC_TIMER;
|
||||
apic_registers.lvt_lint[0].value = idt.INT_LAPIC_LINT0;
|
||||
apic_registers.lvt_lint[1].value = idt.INT_LAPIC_LINT1;
|
||||
// apic_registers.divide_configuration.value = 3u;
|
||||
configure_io_apic_irq(8u, 0x48u);
|
||||
}
|
||||
|
||||
private static void configure_io_apic_irq(size_t io_apic_irq, size_t interrupt_id)
|
||||
{
|
||||
ulong entry = interrupt_id;
|
||||
io_apic_registers.address.value = cast(uint)(0x10u + io_apic_irq * 2u);
|
||||
io_apic_registers.data.value = entry & 0xFFFF_FFFFu;
|
||||
io_apic_registers.address.value = cast(uint)(0x10u + io_apic_irq * 2u + 1u);
|
||||
io_apic_registers.data.value = entry >> 32u;
|
||||
}
|
||||
|
||||
public static void eoi()
|
||||
{
|
||||
apic_registers.eoi.value = 0u;
|
||||
}
|
||||
|
||||
public static void isr(ulong vector)
|
||||
{
|
||||
klog.writefln("APIC ISR 0x%x", vector);
|
||||
eoi();
|
||||
}
|
||||
}
|
||||
@ -1,77 +0,0 @@
|
||||
/**
|
||||
* HULK boot information.
|
||||
*/
|
||||
module hulk.bootinfo;
|
||||
|
||||
/**
|
||||
* HULK boot information structure.
|
||||
*/
|
||||
struct BootInfo
|
||||
{
|
||||
/**
|
||||
* Framebuffer description structure.
|
||||
*/
|
||||
struct Framebuffer
|
||||
{
|
||||
/** Framebuffer physical base address. */
|
||||
uint * buffer;
|
||||
/** Horizontal resolution. */
|
||||
uint width;
|
||||
/** Vertical resolution. */
|
||||
uint height;
|
||||
/** Number of pixels per scan line. */
|
||||
uint stride;
|
||||
/** Pixel format. */
|
||||
uint format;
|
||||
}
|
||||
|
||||
/**
|
||||
* Memory map entry description structure.
|
||||
*/
|
||||
struct MemoryRegion
|
||||
{
|
||||
enum Type
|
||||
{
|
||||
Reserved,
|
||||
Bootloader,
|
||||
Conventional,
|
||||
Unusable,
|
||||
ACPIReclaim,
|
||||
ACPINVS,
|
||||
MemoryMappedIO,
|
||||
MemoryMappedIOPortSpace,
|
||||
PalCode,
|
||||
}
|
||||
|
||||
/** Base address of the memory region. */
|
||||
ulong base;
|
||||
/** Size in bytes of the memory region. */
|
||||
size_t size;
|
||||
/** Type of the memory region. */
|
||||
ubyte type;
|
||||
}
|
||||
|
||||
/* Framebuffer parameters. */
|
||||
Framebuffer fb;
|
||||
|
||||
/* Memory map. */
|
||||
MemoryRegion[1000] memory_map;
|
||||
|
||||
/* Number of memory map entries. */
|
||||
size_t memory_map_count;
|
||||
|
||||
/* Physical address of HULK. */
|
||||
ulong hulk_phys;
|
||||
|
||||
/* Physical address used for HULK bss section. */
|
||||
ulong bss_phys;
|
||||
|
||||
/* Physical address of stack while jumping to HULK. */
|
||||
ulong stack_phys;
|
||||
|
||||
/* Physical address of framebuffer buffer1. */
|
||||
ulong fb_buffer1_phys;
|
||||
|
||||
/* Physical address of ACPI XSDT table. */
|
||||
ulong acpi_xsdt_phys;
|
||||
}
|
||||
@ -1,102 +0,0 @@
|
||||
/**
|
||||
* HULK Console functionality.
|
||||
*/
|
||||
module hulk.console;
|
||||
|
||||
import hulk.fb;
|
||||
import hulk.kfont;
|
||||
|
||||
struct console
|
||||
{
|
||||
/** Console width in text columns. */
|
||||
private static __gshared size_t m_width;
|
||||
|
||||
/** Console height in text rows. */
|
||||
private static __gshared size_t m_height;
|
||||
|
||||
/** Current console cursor X position. */
|
||||
private static __gshared size_t m_x;
|
||||
|
||||
/** Current console cursor Y position. */
|
||||
private static __gshared size_t m_y;
|
||||
|
||||
/**
|
||||
* Initialize the console.
|
||||
*/
|
||||
public static void initialize()
|
||||
{
|
||||
m_width = fb.width / kfont.advance;
|
||||
m_height = fb.height / kfont.line_height;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear the console.
|
||||
*/
|
||||
public static void clear()
|
||||
{
|
||||
fb.clear();
|
||||
m_x = 0u;
|
||||
m_y = 0u;
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a character to the console.
|
||||
*
|
||||
* @param ch Character to write.
|
||||
*/
|
||||
public static void write(char ch)
|
||||
{
|
||||
if (ch == '\n')
|
||||
{
|
||||
m_x = 0u;
|
||||
m_y++;
|
||||
}
|
||||
else
|
||||
{
|
||||
render_char(m_x, m_y, ch);
|
||||
m_x++;
|
||||
if (m_x == m_width)
|
||||
{
|
||||
m_x = 0u;
|
||||
m_y++;
|
||||
}
|
||||
}
|
||||
if (m_y == m_height)
|
||||
{
|
||||
m_y--;
|
||||
fb.copy_rows_up(fb_y(m_height - 1u),
|
||||
(m_height - 1u) * kfont.line_height,
|
||||
kfont.line_height);
|
||||
fb.rect(0u, fb_y(m_height - 1u), fb_x(m_width), kfont.line_height, 0u);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Render a character.
|
||||
*
|
||||
* @param x X position.
|
||||
* @param y Y position.
|
||||
* @param ch Character to render.
|
||||
*/
|
||||
private static void render_char(size_t x, size_t y, char ch)
|
||||
{
|
||||
const(CharInfo) * ci = &kfont.chars[ch];
|
||||
fb.blit_alpha_bitmap(fb_x(x) + ci.left, fb_y(y) + ci.top - ci.height, ci.bitmap, ci.width, ci.height);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the framebuffer X coordinate corresponding to the console X position.
|
||||
*/
|
||||
private static size_t fb_x(size_t x)
|
||||
{
|
||||
return x * kfont.advance;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the framebuffer Y coordinate corresponding to the console Y position.
|
||||
*/
|
||||
private static size_t fb_y(size_t y)
|
||||
{
|
||||
return fb.height - ((y + 1u) * kfont.line_height);
|
||||
}
|
||||
}
|
||||
247
src/hulk/cpu.d
247
src/hulk/cpu.d
@ -1,247 +0,0 @@
|
||||
/**
|
||||
* CPU functionality.
|
||||
*/
|
||||
module hulk.cpu;
|
||||
|
||||
import ldc.llvmasm;
|
||||
|
||||
/** CR0 bits. @{ */
|
||||
enum ulong CR0_PE = 0x1u;
|
||||
enum ulong CR0_MP = 0x2u;
|
||||
enum ulong CR0_EM = 0x4u;
|
||||
enum ulong CR0_TS = 0x8u;
|
||||
enum ulong CR0_ET = 0x10u;
|
||||
enum ulong CR0_NE = 0x20u;
|
||||
enum ulong CR0_WP = 0x1_0000u;
|
||||
enum ulong CR0_AM = 0x4_0000u;
|
||||
enum ulong CR0_NW = 0x2000_0000u;
|
||||
enum ulong CR0_CD = 0x4000_0000u;
|
||||
enum ulong CR0_PG = 0x8000_0000u;
|
||||
/** @} */
|
||||
|
||||
/** CR4 bits. @{ */
|
||||
enum ulong CR4_VME = 0x1u;
|
||||
enum ulong CR4_PVI = 0x2u;
|
||||
enum ulong CR4_TSD = 0x4u;
|
||||
enum ulong CR4_DE = 0x8u;
|
||||
enum ulong CR4_PSE = 0x10u;
|
||||
enum ulong CR4_PAE = 0x20u;
|
||||
enum ulong CR4_MCE = 0x40u;
|
||||
enum ulong CR4_PGE = 0x80u;
|
||||
enum ulong CR4_PCE = 0x100u;
|
||||
enum ulong CR4_OSFXSR = 0x200u;
|
||||
enum ulong CR4_OSXMMEXCPT = 0x400u;
|
||||
enum ulong CR4_UMIP = 0x800u;
|
||||
enum ulong CR4_VMXE = 0x2000u;
|
||||
enum ulong CR4_SMXE = 0x4000u;
|
||||
enum ulong CR4_FSGSBASE = 0x1_0000u;
|
||||
enum ulong CR4_PCIDE = 0x2_0000u;
|
||||
enum ulong CR4_OSXSAVE = 0x4_0000u;
|
||||
enum ulong CR4_SMEP = 0x10_0000u;
|
||||
enum ulong CR4_SMAP = 0x20_0000u;
|
||||
enum ulong CR4_PKE = 0x40_0000u;
|
||||
enum ulong CR4_CET = 0x80_0000u;
|
||||
enum ulong CR4_PKS = 0x100_0000u;
|
||||
/** @} */
|
||||
|
||||
/** XCR0 bits. @{ */
|
||||
enum ulong XCR0_X87 = 0x1u;
|
||||
enum ulong XCR0_SSE = 0x2u;
|
||||
enum ulong XCR0_AVX = 0x4u;
|
||||
enum ulong XCR0_BNDREG = 0x8u;
|
||||
enum ulong XCR0_BNDSCR = 0x10u;
|
||||
enum ulong XCR0_OPMASK = 0x20u;
|
||||
enum ulong XCR0_ZMM_HI256 = 0x40u;
|
||||
enum ulong XCR0_HI16_ZMM = 0x80u;
|
||||
enum ulong XCR0_PKRU = 0x100u;
|
||||
/** @} */
|
||||
|
||||
/** MSR register numbers. @{ */
|
||||
enum uint MSR_EFER = 0xC000_0080u;
|
||||
/** @} */
|
||||
|
||||
/** EFER flags. @{ */
|
||||
enum uint EFER_SCE = 0x1u;
|
||||
enum uint EFER_LME = 0x100u;
|
||||
enum uint EFER_LMA = 0x400u;
|
||||
enum uint EFER_NXE = 0x800u;
|
||||
enum uint EFER_SVME = 0x1000u;
|
||||
enum uint EFER_LMSLE = 0x2000u;
|
||||
enum uint EFER_FFXSR = 0x4000u;
|
||||
enum uint EFER_TCE = 0x8000u;
|
||||
/** @} */
|
||||
|
||||
/** CPUID 1 bits. @{ */
|
||||
enum uint CPUID_1_EDX_FPU = 0x1u;
|
||||
enum uint CPUID_1_EDX_VME = 0x2u;
|
||||
enum uint CPUID_1_EDX_DE = 0x4u;
|
||||
enum uint CPUID_1_EDX_PSE = 0x8u;
|
||||
enum uint CPUID_1_EDX_TSC = 0x10u;
|
||||
enum uint CPUID_1_EDX_MSR = 0x20u;
|
||||
enum uint CPUID_1_EDX_PAE = 0x40u;
|
||||
enum uint CPUID_1_EDX_MCE = 0x80u;
|
||||
enum uint CPUID_1_EDX_CX8 = 0x100u;
|
||||
enum uint CPUID_1_EDX_APIC = 0x200u;
|
||||
enum uint CPUID_1_EDX_SEP = 0x800u;
|
||||
enum uint CPUID_1_EDX_MTRR = 0x1000u;
|
||||
enum uint CPUID_1_EDX_PGE = 0x2000u;
|
||||
enum uint CPUID_1_EDX_MCA = 0x4000u;
|
||||
enum uint CPUID_1_EDX_CMOV = 0x8000u;
|
||||
enum uint CPUID_1_EDX_PAT = 0x1_0000u;
|
||||
enum uint CPUID_1_EDX_PSE36 = 0x2_0000u;
|
||||
enum uint CPUID_1_EDX_PSN = 0x4_0000u;
|
||||
enum uint CPUID_1_EDX_CLFSH = 0x8_0000u;
|
||||
enum uint CPUID_1_EDX_DS = 0x20_0000u;
|
||||
enum uint CPUID_1_EDX_ACPI = 0x40_0000u;
|
||||
enum uint CPUID_1_EDX_MMX = 0x80_0000u;
|
||||
enum uint CPUID_1_EDX_FXSR = 0x100_0000u;
|
||||
enum uint CPUID_1_EDX_SSE = 0x200_0000u;
|
||||
enum uint CPUID_1_EDX_SSE2 = 0x400_0000u;
|
||||
enum uint CPUID_1_EDX_SS = 0x800_0000u;
|
||||
enum uint CPUID_1_EDX_HTT = 0x1000_0000u;
|
||||
enum uint CPUID_1_EDX_TM = 0x2000_0000u;
|
||||
enum uint CPUID_1_EDX_IA64 = 0x4000_0000u;
|
||||
enum uint CPUID_1_EDX_PBE = 0x8000_0000u;
|
||||
enum uint CPUID_1_ECX_SSE3 = 0x1u;
|
||||
enum uint CPUID_1_ECX_PCLMULQDQ = 0x2u;
|
||||
enum uint CPUID_1_ECX_DTES64 = 0x4u;
|
||||
enum uint CPUID_1_ECX_MONITOR = 0x8u;
|
||||
enum uint CPUID_1_ECX_DSCPL = 0x10u;
|
||||
enum uint CPUID_1_ECX_VMX = 0x20u;
|
||||
enum uint CPUID_1_ECX_SMX = 0x40u;
|
||||
enum uint CPUID_1_ECX_EST = 0x80u;
|
||||
enum uint CPUID_1_ECX_TM2 = 0x100u;
|
||||
enum uint CPUID_1_ECX_SSSE3 = 0x200u;
|
||||
enum uint CPUID_1_ECX_CNXTID = 0x400u;
|
||||
enum uint CPUID_1_ECX_SDBG = 0x800u;
|
||||
enum uint CPUID_1_ECX_FMA = 0x1000u;
|
||||
enum uint CPUID_1_ECX_CX16 = 0x2000u;
|
||||
enum uint CPUID_1_ECX_XTPR = 0x4000u;
|
||||
enum uint CPUID_1_ECX_PDCM = 0x8000u;
|
||||
enum uint CPUID_1_ECX_PCID = 0x2_0000u;
|
||||
enum uint CPUID_1_ECX_DCA = 0x4_0000u;
|
||||
enum uint CPUID_1_ECX_SSE41 = 0x8_0000u;
|
||||
enum uint CPUID_1_ECX_SSE42 = 0x10_0000u;
|
||||
enum uint CPUID_1_ECX_X2APIC = 0x20_0000u;
|
||||
enum uint CPUID_1_ECX_MOVBE = 0x40_0000u;
|
||||
enum uint CPUID_1_ECX_POPCNT = 0x80_0000u;
|
||||
enum uint CPUID_1_ECX_TSCDEADLINE = 0x100_0000u;
|
||||
enum uint CPUID_1_ECX_AES = 0x200_0000u;
|
||||
enum uint CPUID_1_ECX_XSAVE = 0x400_0000u;
|
||||
enum uint CPUID_1_ECX_OSXSAVE = 0x800_0000u;
|
||||
enum uint CPUID_1_ECX_AVX = 0x1000_0000u;
|
||||
enum uint CPUID_1_ECX_F16C = 0x2000_0000u;
|
||||
enum uint CPUID_1_ECX_RDRND = 0x4000_0000u;
|
||||
enum uint CPUID_1_ECX_HYPERVISOR = 0x8000_0000u;
|
||||
/** @} */
|
||||
|
||||
void cli()
|
||||
{
|
||||
__asm("cli", "");
|
||||
}
|
||||
|
||||
void sti()
|
||||
{
|
||||
__asm("sti", "");
|
||||
}
|
||||
|
||||
void hlt()
|
||||
{
|
||||
__asm("hlt", "");
|
||||
}
|
||||
|
||||
ulong read_cr0()
|
||||
{
|
||||
return __asm!ulong("mov %cr0, %rax", "={rax}");
|
||||
}
|
||||
|
||||
void write_cr0(ulong v)
|
||||
{
|
||||
__asm("mov $0, %cr0", "r", v);
|
||||
}
|
||||
|
||||
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}");
|
||||
}
|
||||
|
||||
void write_cr4(ulong v)
|
||||
{
|
||||
__asm("mov $0, %cr4", "r", v);
|
||||
}
|
||||
|
||||
ulong rdmsr(uint msr)
|
||||
{
|
||||
return __asm!ulong(`
|
||||
rdmsr
|
||||
shl $$32, %rdx
|
||||
or %rdx, %rax`, "={rax},{ecx},~{rdx}", msr);
|
||||
}
|
||||
|
||||
void wrmsr(uint msr, ulong value)
|
||||
{
|
||||
__asm(`wrmsr`, "{ecx},{edx},{eax}", msr, value >> 32u, value);
|
||||
}
|
||||
|
||||
ulong xgetbv(uint xcr)
|
||||
{
|
||||
return __asm!ulong(`
|
||||
xgetbv
|
||||
shl $$32, %rdx
|
||||
or %rdx, %rax`, "={rax},{ecx},~{rdx}", xcr);
|
||||
}
|
||||
|
||||
void xsetbv(uint xcr, ulong value)
|
||||
{
|
||||
__asm(`xsetbv`, "{ecx},{edx},{eax}", xcr, value >> 32u, value);
|
||||
}
|
||||
|
||||
ubyte in8(ushort ioaddr)
|
||||
{
|
||||
return __asm!ubyte("inb %dx, %al", "={al},{dx}", ioaddr);
|
||||
}
|
||||
|
||||
ushort in16(ushort ioaddr)
|
||||
{
|
||||
return __asm!ushort("inw %dx, %ax", "={ax},{dx}", ioaddr);
|
||||
}
|
||||
|
||||
ulong in32(ushort ioaddr)
|
||||
{
|
||||
return __asm!ulong("inl %dx, %eax", "={eax},{dx}", ioaddr);
|
||||
}
|
||||
|
||||
void out8(ushort ioaddr, ubyte v)
|
||||
{
|
||||
__asm("outb %al, %dx", "{dx},{al}", ioaddr, v);
|
||||
}
|
||||
|
||||
void out16(ushort ioaddr, ushort v)
|
||||
{
|
||||
__asm("outw %ax, %dx", "{dx},{ax}", ioaddr, v);
|
||||
}
|
||||
|
||||
void out32(ushort ioaddr, ulong v)
|
||||
{
|
||||
__asm("outl %eax, %dx", "{dx},{eax}", ioaddr, v);
|
||||
}
|
||||
|
||||
void cpuid1(uint * ebx, uint * ecx, uint * edx)
|
||||
{
|
||||
__asm("cpuid", "=*{ebx},=*{ecx},=*{edx},{eax}", ebx, ecx, edx, 1u);
|
||||
}
|
||||
292
src/hulk/fb.d
292
src/hulk/fb.d
@ -1,292 +0,0 @@
|
||||
/**
|
||||
* HULK Framebuffer support.
|
||||
*/
|
||||
module hulk.fb;
|
||||
|
||||
import hulk.memory;
|
||||
import hulk.kfont;
|
||||
|
||||
/**
|
||||
* Represent a graphical frame buffer.
|
||||
*
|
||||
* TODO: Handle other pixel formats. Currently only BGRx is supported.
|
||||
*/
|
||||
struct fb
|
||||
{
|
||||
/** Device frame buffer base address. */
|
||||
private __gshared static uint * m_device_buffer;
|
||||
|
||||
/** Frame buffer 1 base address. */
|
||||
private __gshared static uint * m_buffer1;
|
||||
|
||||
/** Frame buffer width. */
|
||||
private __gshared static uint m_width;
|
||||
|
||||
/** Frame buffer height. */
|
||||
private __gshared static uint m_height;
|
||||
|
||||
/** Frame buffer stride. */
|
||||
private __gshared static uint m_stride;
|
||||
|
||||
/** Number of pixels in the frame buffer (whether visible or not). */
|
||||
private __gshared static uint m_buffer_size;
|
||||
|
||||
/**
|
||||
* Get the framebuffer width.
|
||||
*/
|
||||
public static @property uint width()
|
||||
{
|
||||
return m_width;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the framebuffer height.
|
||||
*/
|
||||
public static @property uint height()
|
||||
{
|
||||
return m_height;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize a frame buffer.
|
||||
*
|
||||
* @param device_buffer Device frame buffer base address.
|
||||
* @param buffer1 Frame buffer 1 base address.
|
||||
* @param width Frame buffer width.
|
||||
* @param height Frame buffer height.
|
||||
* @param stride Frame buffer stride.
|
||||
*/
|
||||
static void initialize(uint * device_buffer, uint * buffer1, uint width, uint height, uint stride)
|
||||
{
|
||||
m_device_buffer = device_buffer;
|
||||
m_buffer1 = buffer1;
|
||||
m_width = width;
|
||||
m_height = height;
|
||||
m_stride = stride;
|
||||
m_buffer_size = stride * height;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear the frame buffer to the given color.
|
||||
*
|
||||
* @param color Color to clear to.
|
||||
*/
|
||||
static void clear(uint color = 0u)
|
||||
{
|
||||
memset32(m_buffer1, color, m_buffer_size);
|
||||
memset32(m_device_buffer, color, m_buffer_size);
|
||||
}
|
||||
|
||||
/**
|
||||
* Draw a solid rectangle on the framebuffer.
|
||||
*
|
||||
* @param x X coordinate of left side of rectangle.
|
||||
* @param y Y coordinate of bottom side of rectangle.
|
||||
* @param width Width of rectangle.
|
||||
* @param height Height of rectangle.
|
||||
* @param color Color of rectangle.
|
||||
*/
|
||||
static void rect(size_t x, size_t y, size_t width, size_t height, uint color)
|
||||
{
|
||||
for (size_t iy = 0u; iy < height; iy++)
|
||||
{
|
||||
size_t buffer_index = buffer_index(x, y);
|
||||
memset32(&m_buffer1[buffer_index], color, width);
|
||||
memset32(&m_device_buffer[buffer_index], color, width);
|
||||
y++;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Draw a horizontal line.
|
||||
*
|
||||
* @param x X coordinate of left side of line.
|
||||
* @param y Y coordinate of line.
|
||||
* @param width Width of line.
|
||||
* @param color Color of line.
|
||||
*/
|
||||
static void hline(size_t x, size_t y, size_t width, uint color)
|
||||
{
|
||||
size_t buffer_index = buffer_index(x, y);
|
||||
memset32(&m_buffer1[buffer_index], color, width);
|
||||
memset32(&m_device_buffer[buffer_index], color, width);
|
||||
}
|
||||
|
||||
/**
|
||||
* Draw a vertical line.
|
||||
*
|
||||
* @param x X coordinate of line.
|
||||
* @param y Y coordinate of bottom of line.
|
||||
* @param height Height of line.
|
||||
* @param color Color of line.
|
||||
*/
|
||||
static void vline(size_t x, size_t y, size_t height, uint color)
|
||||
{
|
||||
size_t buffer_index = buffer_index(x, y);
|
||||
for (size_t iy = 0u; iy < height; iy++)
|
||||
{
|
||||
m_buffer1[buffer_index] = color;
|
||||
m_device_buffer[buffer_index] = color;
|
||||
buffer_index -= m_stride;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Draw a character.
|
||||
*
|
||||
* @param x X coordinate of left side of character.
|
||||
* @param y Y coordinate of bottom side of character.
|
||||
* @param ch Character to draw.
|
||||
* @param color Color of character.
|
||||
*/
|
||||
static void character(int x, int y, char ch, uint color)
|
||||
{
|
||||
const(CharInfo) * ci = &kfont.chars[ch];
|
||||
blend_alpha_bitmap(x + ci.left, y + kfont.baseline_offset + ci.top - ci.height, ci.bitmap, ci.width, ci.height, color);
|
||||
}
|
||||
|
||||
/**
|
||||
* Blend an 8-bit alpha bitmap to the framebuffer.
|
||||
*
|
||||
* @param x X coordinate of left side of target location.
|
||||
* @param y Y coordinate of bottom side of target location.
|
||||
* @param alpha_bitmap 8-bit alpha-channel bitmap.
|
||||
* @param width Bitmap width.
|
||||
* @param height Bitmap height.
|
||||
* @param color Color to blend with alpha value.
|
||||
*/
|
||||
static void blend_alpha_bitmap(size_t x, size_t y, const(ubyte) * alpha_bitmap,
|
||||
size_t width, size_t height, uint color)
|
||||
{
|
||||
y += height - 1u;
|
||||
size_t bitmap_index;
|
||||
for (size_t iy = 0u; iy < height; iy++)
|
||||
{
|
||||
size_t row_buffer_index = buffer_index(x, y);
|
||||
for (size_t ix = 0u; ix < width; ix++)
|
||||
{
|
||||
size_t buffer_index = row_buffer_index + ix;
|
||||
ubyte alpha = alpha_bitmap[bitmap_index];
|
||||
uint current_color = m_buffer1[buffer_index];
|
||||
uint in_color_scaled = scale_color(color, alpha);
|
||||
uint old_color_scaled = scale_color(current_color, 255u - alpha);
|
||||
uint new_color = old_color_scaled + in_color_scaled;
|
||||
m_buffer1[buffer_index] = new_color;
|
||||
bitmap_index++;
|
||||
}
|
||||
memcpy32(&m_device_buffer[row_buffer_index], &m_buffer1[row_buffer_index], width);
|
||||
y--;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Blend an 8-bit alpha bitmap to the framebuffer.
|
||||
*
|
||||
* @param x X coordinate of left side of target location.
|
||||
* @param y Y coordinate of bottom side of target location.
|
||||
* @param alpha_bitmap 8-bit alpha-channel bitmap.
|
||||
* @param width Bitmap width.
|
||||
* @param height Bitmap height.
|
||||
* @param color Color to blend with alpha value.
|
||||
*/
|
||||
static void blend_alpha_bitmap(size_t x, size_t y, const(ubyte)[] alpha_bitmap,
|
||||
size_t width, size_t height, uint color)
|
||||
{
|
||||
blend_alpha_bitmap(x, y, alpha_bitmap.ptr, width, height, color);
|
||||
}
|
||||
|
||||
/**
|
||||
* Blit an 8-bit alpha bitmap to the framebuffer.
|
||||
* The foreground will be white (based on the alpha value), and the
|
||||
* background black.
|
||||
*
|
||||
* @param x X coordinate of left side of target location.
|
||||
* @param y Y coordinate of bottom side of target location.
|
||||
* @param alpha_bitmap 8-bit alpha-channel bitmap.
|
||||
* @param width Bitmap width.
|
||||
* @param height Bitmap height.
|
||||
*/
|
||||
static void blit_alpha_bitmap(size_t x, size_t y, const(ubyte) * alpha_bitmap,
|
||||
size_t width, size_t height)
|
||||
{
|
||||
y += height - 1u;
|
||||
size_t bitmap_index;
|
||||
for (size_t iy = 0u; iy < height; iy++)
|
||||
{
|
||||
size_t row_buffer_index = buffer_index(x, y);
|
||||
for (size_t ix = 0u; ix < width; ix++)
|
||||
{
|
||||
size_t buffer_index = row_buffer_index + ix;
|
||||
ubyte alpha = alpha_bitmap[bitmap_index];
|
||||
m_buffer1[buffer_index] = (alpha << 16u) | (alpha << 8u) | alpha;
|
||||
bitmap_index++;
|
||||
}
|
||||
memcpy32(&m_device_buffer[row_buffer_index], &m_buffer1[row_buffer_index], width);
|
||||
y--;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Blit an 8-bit alpha bitmap to the framebuffer.
|
||||
* The foreground will be white (based on the alpha value), and the
|
||||
* background black.
|
||||
*
|
||||
* @param x X coordinate of left side of target location.
|
||||
* @param y Y coordinate of bottom side of target location.
|
||||
* @param alpha_bitmap 8-bit alpha-channel bitmap.
|
||||
* @param width Bitmap width.
|
||||
* @param height Bitmap height.
|
||||
*/
|
||||
static void blit_alpha_bitmap(size_t x, size_t y, const(ubyte)[] alpha_bitmap,
|
||||
size_t width, size_t height)
|
||||
{
|
||||
blit_alpha_bitmap(x, y, alpha_bitmap.ptr, width, height);
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy framebuffer rows up in the framebuffer.
|
||||
*
|
||||
* @param y Y coordinate of bottom side of region to copy up.
|
||||
* @param height Height of region to copy up.
|
||||
* @param offset Number of rows to copy region up by.
|
||||
*/
|
||||
static void copy_rows_up(size_t y, size_t height, size_t offset)
|
||||
{
|
||||
size_t dest_buffer_index = buffer_index(0u, y + height + offset - 1u);
|
||||
size_t src_buffer_index = buffer_index(0u, y + height - 1u);
|
||||
memcpy32(&m_buffer1[dest_buffer_index],
|
||||
&m_buffer1[src_buffer_index],
|
||||
(m_stride * height));
|
||||
memcpy32(&m_device_buffer[dest_buffer_index],
|
||||
&m_buffer1[dest_buffer_index],
|
||||
(m_stride * height));
|
||||
}
|
||||
|
||||
/**
|
||||
* Scale a color value by an alpha amount.
|
||||
*
|
||||
* @param color Color value.
|
||||
* @param alpha Alpha amount.
|
||||
*
|
||||
* @return Scaled color value.
|
||||
*/
|
||||
private static uint scale_color(uint color, ubyte alpha)
|
||||
{
|
||||
return ((((color & 0xFFu) * alpha) >> 8u) & 0xFFu) |
|
||||
((((color & 0xFF00u) * alpha) >> 8u) & 0xFF00u) |
|
||||
((((color & 0xFF0000u) * alpha) >> 8u) & 0xFF0000u);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the buffer index for the given X and Y coordinates.
|
||||
*
|
||||
* @param x X coordinate from left side of framebuffer.
|
||||
* @param y Y coordinate from bottom side of framebuffer.
|
||||
*
|
||||
* @return Buffer index for the given X and Y coordinates.
|
||||
*/
|
||||
private static size_t buffer_index(size_t x, size_t y)
|
||||
{
|
||||
return (m_height - y - 1u) * m_stride + x;
|
||||
}
|
||||
}
|
||||
@ -1,58 +0,0 @@
|
||||
/**
|
||||
* GDT (Global Descriptor Table) functionality.
|
||||
*/
|
||||
module hulk.gdt;
|
||||
|
||||
import ldc.llvmasm;
|
||||
|
||||
struct gdt
|
||||
{
|
||||
struct gdtr_t
|
||||
{
|
||||
ushort limit;
|
||||
align(2) ulong offset;
|
||||
}
|
||||
static assert(gdtr_t.sizeof == 10u);
|
||||
|
||||
public enum size_t SELECTOR_NULL = 0x00u;
|
||||
public enum size_t SELECTOR_KERNEL_CODE = 0x08u;
|
||||
public enum size_t SELECTOR_KERNEL_DATA = 0x10u;
|
||||
public enum size_t SELECTOR_COUNT = 3u;
|
||||
|
||||
static __gshared ulong[SELECTOR_COUNT] gdt;
|
||||
static __gshared gdtr_t gdtr;
|
||||
|
||||
public static void initialize()
|
||||
{
|
||||
gdt[SELECTOR_KERNEL_CODE / ulong.sizeof] = 0x00_A_F_9A_000000_0000u;
|
||||
gdt[SELECTOR_KERNEL_DATA / ulong.sizeof] = 0x00_C_F_92_000000_0000u;
|
||||
gdtr.limit = gdt.sizeof - 1u;
|
||||
gdtr.offset = cast(ulong)&gdt;
|
||||
lgdt(&gdtr);
|
||||
load_data_selectors(SELECTOR_KERNEL_DATA);
|
||||
load_code_selector(SELECTOR_KERNEL_CODE);
|
||||
}
|
||||
|
||||
private static void lgdt(gdtr_t * gdtr)
|
||||
{
|
||||
__asm("lgdt $0", "*m", gdtr);
|
||||
}
|
||||
|
||||
private static void load_data_selectors(ulong selector)
|
||||
{
|
||||
__asm(`mov %ax, %ds
|
||||
mov %ax, %es
|
||||
mov %ax, %fs
|
||||
mov %ax, %gs
|
||||
mov %ax, %ss`, "{rax}", selector);
|
||||
}
|
||||
|
||||
private static void load_code_selector(ulong selector)
|
||||
{
|
||||
__asm(`push %rax
|
||||
movabs $$1f, %rax
|
||||
push %rax
|
||||
lretq
|
||||
1:`, "{rax}", selector);
|
||||
}
|
||||
}
|
||||
@ -1,40 +0,0 @@
|
||||
/**
|
||||
* HULK image header.
|
||||
*/
|
||||
module hulk.header;
|
||||
|
||||
import hulk.bootinfo;
|
||||
|
||||
/**
|
||||
* Header describing the HULK image.
|
||||
*/
|
||||
struct HulkHeader
|
||||
{
|
||||
/**
|
||||
* HULK BSS size.
|
||||
*
|
||||
* The OS loader must map memory to a zeroed range of this size.
|
||||
*
|
||||
* This value is really an integer, but is stored as a pointer because it
|
||||
* is provided by the linker and LDC does not like us to cast it.
|
||||
*/
|
||||
void * hulk_bss_size;
|
||||
|
||||
/** Entry point. */
|
||||
void * entry;
|
||||
|
||||
/** Stack size. */
|
||||
ulong stack_size;
|
||||
|
||||
/** Virtual base address. */
|
||||
ulong virt_base;
|
||||
|
||||
/** Stack top virtual address. */
|
||||
ulong virt_stack_top;
|
||||
|
||||
/** Framebuffer virtual address. */
|
||||
ulong virt_fb_buffer;
|
||||
|
||||
/** HULK boot information. */
|
||||
BootInfo bootinfo;
|
||||
}
|
||||
@ -1,69 +0,0 @@
|
||||
/**
|
||||
* HIPPO, the HOS In-place Physical Page Organizer.
|
||||
*
|
||||
* HIPPO maintains a list of free physical pages "in place", meaning that the
|
||||
* available page itself is used as the linked list entry so separate memory
|
||||
* is not needed to keep track of the available pages.
|
||||
*/
|
||||
module hulk.hippo;
|
||||
|
||||
struct hippo
|
||||
{
|
||||
/**
|
||||
* Linked list node entry for a physical page.
|
||||
*/
|
||||
private static struct PhysicalPage
|
||||
{
|
||||
PhysicalPage * next;
|
||||
}
|
||||
|
||||
/**
|
||||
* Linked list of free physical pages.
|
||||
*/
|
||||
private static __gshared PhysicalPage * free_pages;
|
||||
|
||||
/**
|
||||
* Number of free physical pages.
|
||||
*/
|
||||
private static __gshared size_t m_n_free_pages;
|
||||
|
||||
/**
|
||||
* Free a physical page.
|
||||
*
|
||||
* @param phys Physical page address.
|
||||
*/
|
||||
public static void free_page(T)(T phys)
|
||||
{
|
||||
PhysicalPage * pp = cast(PhysicalPage *)phys;
|
||||
pp.next = free_pages;
|
||||
free_pages = pp;
|
||||
m_n_free_pages++;
|
||||
}
|
||||
|
||||
/**
|
||||
* Allocate a physical page.
|
||||
*
|
||||
* @return Page address, or null if no pages are available.
|
||||
*/
|
||||
public static void * allocate_page()
|
||||
{
|
||||
PhysicalPage * pp;
|
||||
if (free_pages != null)
|
||||
{
|
||||
pp = free_pages;
|
||||
free_pages = free_pages.next;
|
||||
m_n_free_pages--;
|
||||
}
|
||||
return cast(void *)pp;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the number of free pages.
|
||||
*
|
||||
* @return The number of free pages.
|
||||
*/
|
||||
public @property size_t n_free_pages() const
|
||||
{
|
||||
return m_n_free_pages;
|
||||
}
|
||||
}
|
||||
@ -1,86 +0,0 @@
|
||||
/**
|
||||
* HULK, the HOS Ultra Light Kernel.
|
||||
*/
|
||||
module hulk.hulk;
|
||||
|
||||
import hulk.header;
|
||||
import hulk.fb;
|
||||
import hulk.console;
|
||||
import hulk.memory;
|
||||
import ldc.attributes;
|
||||
import hulk.kfont;
|
||||
import hulk.klog;
|
||||
import hulk.hurl;
|
||||
import hulk.hippo;
|
||||
import hulk.pci;
|
||||
import hulk.gdt;
|
||||
import hulk.idt;
|
||||
import hulk.cpu;
|
||||
import ldc.llvmasm;
|
||||
import hulk.pic;
|
||||
import hulk.acpi;
|
||||
import hulk.apic;
|
||||
import hulk.rtc;
|
||||
import hulk.pit;
|
||||
|
||||
extern extern(C) __gshared ubyte _hulk_bss_size;
|
||||
|
||||
@(ldc.attributes.section(".hulk_header"))
|
||||
private __gshared HulkHeader hulk_header = {
|
||||
&_hulk_bss_size, /* hulk_bss_size */
|
||||
&hulk_start, /* entry */
|
||||
16u * 1024u, /* stack_size */
|
||||
HULK_VIRTUAL_BASE_ADDRESS, /* virt_base */
|
||||
HULK_VIRTUAL_STACK_TOP_ADDRESS, /* virt_stack_top */
|
||||
HULK_VIRTUAL_FRAMEBUFFER_ADDRESS, /* virt_fb_buffer */
|
||||
};
|
||||
|
||||
private void initialize_cpu()
|
||||
{
|
||||
/* Enable SSE. */
|
||||
/* Turn off CR0.EM and turn on CR0.MP. */
|
||||
write_cr0((read_cr0() & ~CR0_EM) | CR0_MP);
|
||||
/* Set CR4.OSFXSR and CR4.OSXMMEXCPT. */
|
||||
write_cr4(read_cr4() | CR4_OSFXSR | CR4_OSXMMEXCPT);
|
||||
|
||||
/* Enable OSXSAVE. */
|
||||
write_cr4(read_cr4() | CR4_OSXSAVE);
|
||||
|
||||
/* Turn on NXE (no execute enable) flag in the EFER MSR. */
|
||||
wrmsr(MSR_EFER, rdmsr(MSR_EFER) | EFER_NXE);
|
||||
}
|
||||
|
||||
/**
|
||||
* HULK entry point.
|
||||
*/
|
||||
void hulk_start()
|
||||
{
|
||||
cli();
|
||||
initialize_cpu();
|
||||
gdt.initialize();
|
||||
idt.initialize();
|
||||
fb.initialize(cast(uint *)HULK_VIRTUAL_FRAMEBUFFER_ADDRESS,
|
||||
cast(uint *)hulk_header.bootinfo.fb_buffer1_phys,
|
||||
hulk_header.bootinfo.fb.width,
|
||||
hulk_header.bootinfo.fb.height,
|
||||
hulk_header.bootinfo.fb.stride);
|
||||
console.initialize();
|
||||
console.clear();
|
||||
klog.initialize();
|
||||
|
||||
klog.writefln("Welcome to HULK, the HOS UltraLight Kernel!");
|
||||
|
||||
hurl.initialize(&hulk_header);
|
||||
pci.initialize();
|
||||
pic.initialize();
|
||||
acpi.initialize(hulk_header.bootinfo.acpi_xsdt_phys);
|
||||
apic.initialize();
|
||||
rtc.initialize();
|
||||
pit.initialize();
|
||||
sti();
|
||||
|
||||
for (;;)
|
||||
{
|
||||
hlt();
|
||||
}
|
||||
}
|
||||
@ -1,61 +0,0 @@
|
||||
SECTIONS
|
||||
{
|
||||
. = 0xFFFF800000000000;
|
||||
_hulk_mem_start = .;
|
||||
_hulk_header_start = .;
|
||||
|
||||
.hulk_header :
|
||||
{
|
||||
*(.hulk_header)
|
||||
}
|
||||
|
||||
. = ALIGN(4K);
|
||||
_hulk_header_end = .;
|
||||
_hulk_text_start = .;
|
||||
|
||||
.text :
|
||||
{
|
||||
*(.text)
|
||||
}
|
||||
|
||||
. = ALIGN(4K);
|
||||
_hulk_text_end = .;
|
||||
_hulk_rodata_start = .;
|
||||
|
||||
.rodata :
|
||||
{
|
||||
*(.rodata)
|
||||
}
|
||||
|
||||
. = ALIGN(4K);
|
||||
|
||||
_hulk_rodata_end = .;
|
||||
_hulk_data_start = .;
|
||||
|
||||
.data :
|
||||
{
|
||||
*(.data)
|
||||
}
|
||||
|
||||
. = ALIGN(4K);
|
||||
_hulk_data_end = .;
|
||||
_hulk_binary_size = . - _hulk_mem_start;
|
||||
_hulk_bss_start = .;
|
||||
|
||||
.bss :
|
||||
{
|
||||
*(COMMON)
|
||||
*(.bss)
|
||||
}
|
||||
|
||||
. = ALIGN(4K);
|
||||
_hulk_bss_end = .;
|
||||
_hulk_mem_end = .;
|
||||
|
||||
_hulk_header_size = _hulk_header_end - _hulk_header_start;
|
||||
_hulk_text_size = _hulk_text_end - _hulk_text_start;
|
||||
_hulk_rodata_size = _hulk_rodata_end - _hulk_rodata_start;
|
||||
_hulk_data_size = _hulk_data_end - _hulk_data_start;
|
||||
_hulk_bss_size = _hulk_bss_end - _hulk_bss_start;
|
||||
_hulk_mem_size = _hulk_mem_end - _hulk_mem_start;
|
||||
}
|
||||
296
src/hulk/hurl.d
296
src/hulk/hurl.d
@ -1,296 +0,0 @@
|
||||
/**
|
||||
* HURL, the HOS Unreal Region Locator.
|
||||
*
|
||||
* HURL provides virtual memory management for HULK.
|
||||
*/
|
||||
module hulk.hurl;
|
||||
|
||||
public import hulk.pagetable;
|
||||
import hulk.cpu;
|
||||
import hulk.hippo;
|
||||
import hulk.memory;
|
||||
import hulk.klog;
|
||||
import hulk.bootinfo;
|
||||
import hulk.header;
|
||||
import hulk.linker_addresses;
|
||||
|
||||
/** HULK virtual base address. */
|
||||
enum ulong HULK_VIRTUAL_BASE_ADDRESS = 0xFFFF_8000_0000_0000u;
|
||||
|
||||
/** HULK virtual stack top address. */
|
||||
enum ulong HULK_VIRTUAL_STACK_TOP_ADDRESS = 0xFFFF_A000_0000_0000u;
|
||||
|
||||
/** HULK virtual framebuffer address. */
|
||||
enum ulong HULK_VIRTUAL_FRAMEBUFFER_ADDRESS = 0xFFFF_A000_0000_0000u;
|
||||
|
||||
struct hurl
|
||||
{
|
||||
/**
|
||||
* Pointer to the base page table.
|
||||
*/
|
||||
private static __gshared PageTable * m_pt_base;
|
||||
|
||||
/**
|
||||
* Build HULK page tables.
|
||||
*
|
||||
* @param physical_address_limit
|
||||
* Limit of physical memory.
|
||||
*/
|
||||
private static void build_page_tables(HulkHeader * header, size_t physical_address_limit)
|
||||
{
|
||||
m_pt_base = allocate_pt();
|
||||
/* Identity map all physical RAM. */
|
||||
map_range(0u,
|
||||
0u,
|
||||
physical_address_limit,
|
||||
PT_WRITABLE | PT_NO_EXECUTE);
|
||||
ulong phys_address = header.bootinfo.hulk_phys;
|
||||
ulong virt_address = HULK_VIRTUAL_BASE_ADDRESS;
|
||||
/* Map HULK header region. */
|
||||
map_range(virt_address,
|
||||
phys_address,
|
||||
LinkerAddresses.hulk_header_size,
|
||||
PT_NO_EXECUTE);
|
||||
phys_address += LinkerAddresses.hulk_header_size;
|
||||
virt_address += LinkerAddresses.hulk_header_size;
|
||||
/* Map HULK text region. */
|
||||
map_range(virt_address,
|
||||
phys_address,
|
||||
LinkerAddresses.hulk_text_size,
|
||||
0u);
|
||||
phys_address += LinkerAddresses.hulk_text_size;
|
||||
virt_address += LinkerAddresses.hulk_text_size;
|
||||
/* Map HULK rodata region. */
|
||||
map_range(virt_address,
|
||||
phys_address,
|
||||
LinkerAddresses.hulk_rodata_size,
|
||||
PT_NO_EXECUTE);
|
||||
phys_address += LinkerAddresses.hulk_rodata_size;
|
||||
virt_address += LinkerAddresses.hulk_rodata_size;
|
||||
/* Map HULK data region. */
|
||||
map_range(virt_address,
|
||||
phys_address,
|
||||
LinkerAddresses.hulk_data_size,
|
||||
PT_WRITABLE | PT_NO_EXECUTE);
|
||||
virt_address += LinkerAddresses.hulk_data_size;
|
||||
/* Map HULK BSS region. */
|
||||
map_range(virt_address,
|
||||
header.bootinfo.bss_phys,
|
||||
LinkerAddresses.hulk_bss_size,
|
||||
PT_WRITABLE | PT_NO_EXECUTE);
|
||||
/* Map HULK stack. */
|
||||
map_range(HULK_VIRTUAL_STACK_TOP_ADDRESS - header.stack_size,
|
||||
header.bootinfo.stack_phys,
|
||||
header.stack_size,
|
||||
PT_WRITABLE | PT_NO_EXECUTE);
|
||||
/* Map device framebuffer. */
|
||||
map_range(HULK_VIRTUAL_FRAMEBUFFER_ADDRESS,
|
||||
cast(ulong)header.bootinfo.fb.buffer,
|
||||
header.bootinfo.fb.height * header.bootinfo.fb.stride * 4u,
|
||||
PT_WRITABLE | PT_NO_EXECUTE);
|
||||
/* Map framebuffer buffer1. */
|
||||
map_range(cast(ulong)header.bootinfo.fb_buffer1_phys,
|
||||
cast(ulong)header.bootinfo.fb_buffer1_phys,
|
||||
header.bootinfo.fb.height * header.bootinfo.fb.stride * 4u,
|
||||
PT_WRITABLE | PT_NO_EXECUTE);
|
||||
write_cr3(cast(ulong)m_pt_base);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reclaim the pages that were used for the bootloader page tables.
|
||||
*
|
||||
* @param pt
|
||||
* The page table to reclaim pages from.
|
||||
* @param level
|
||||
* Page table level (internally used while recursing the page tables).
|
||||
*
|
||||
* @return Number of pages reclaimed.
|
||||
*/
|
||||
private static size_t reclaim_bootloader_page_table_pages(PageTable * pt, size_t level = 0u)
|
||||
{
|
||||
map(pt, pt, PT_WRITABLE | PT_NO_EXECUTE);
|
||||
size_t reclaimed_pages;
|
||||
for (size_t i = 0u; i < PageTable.N_ENTRIES; i++)
|
||||
{
|
||||
PageTableEntry pte = (*pt)[i];
|
||||
if (pte.present && (level < 2u) && !pte.huge)
|
||||
{
|
||||
/* For the first two levels of page tables, first
|
||||
* recurse and free pages from the lower level page
|
||||
* tables before reclaiming this entry. */
|
||||
reclaimed_pages += reclaim_bootloader_page_table_pages(pte.follow(), level + 1u);
|
||||
}
|
||||
}
|
||||
hippo.free_page(pt);
|
||||
reclaimed_pages++;
|
||||
return reclaimed_pages;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize HURL.
|
||||
*
|
||||
* @param bootinfo HULK boot information structure.
|
||||
*/
|
||||
public static void initialize(HulkHeader * header)
|
||||
{
|
||||
PageTable * bootloader_pt_base = cast(PageTable *)read_cr3();
|
||||
|
||||
/*
|
||||
* Ok, what we do here is iterate through all of the memory map regions
|
||||
* in the bootinfo memory_map array and mark each page that is not in
|
||||
* use in a reserved range as available. Within the available memory
|
||||
* regions, we have to watch out for the following items:
|
||||
* 1) HULK binary (header + text + rodata + data)
|
||||
* 2) Framebuffer
|
||||
* In addition to these ranges, there are also pages for the following
|
||||
* purposes that are not represented in the memory map from the
|
||||
* bootloader:
|
||||
* 3) HULK BSS
|
||||
* 4) HULK stack
|
||||
* 5) bootloader page table pages
|
||||
* 6) framebuffer buffer1
|
||||
*/
|
||||
size_t usable_memory;
|
||||
size_t physical_address_limit;
|
||||
const(size_t) fb_size = (header.bootinfo.fb.height * header.bootinfo.fb.stride * 4u + PAGE_SIZE - 1u) & ~(PAGE_SIZE - 1u);
|
||||
ulong[2][2] reserved = [
|
||||
[header.bootinfo.hulk_phys, LinkerAddresses.hulk_binary_size],
|
||||
[cast(ulong)header.bootinfo.fb.buffer, fb_size],
|
||||
];
|
||||
for (size_t ri = 0u; ri < reserved.length; ri++)
|
||||
{
|
||||
reserved[ri][1] += reserved[ri][0];
|
||||
}
|
||||
for (size_t bii = 0u; bii < header.bootinfo.memory_map_count; bii++)
|
||||
{
|
||||
if ((header.bootinfo.memory_map[bii].type == BootInfo.MemoryRegion.Type.Bootloader) ||
|
||||
(header.bootinfo.memory_map[bii].type == BootInfo.MemoryRegion.Type.Conventional))
|
||||
{
|
||||
ulong phys = header.bootinfo.memory_map[bii].base;
|
||||
ulong phys_end = phys + header.bootinfo.memory_map[bii].size;
|
||||
if (phys_end > physical_address_limit)
|
||||
{
|
||||
physical_address_limit = phys_end;
|
||||
}
|
||||
usable_memory += header.bootinfo.memory_map[bii].size;
|
||||
while (phys < phys_end)
|
||||
{
|
||||
bool is_reserved = false;
|
||||
for (size_t ri = 0u; ri < reserved.length; ri++)
|
||||
{
|
||||
if ((reserved[ri][0] <= phys) && (phys < reserved[ri][1]))
|
||||
{
|
||||
is_reserved = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!is_reserved)
|
||||
{
|
||||
hippo.free_page(phys);
|
||||
}
|
||||
phys += PAGE_SIZE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Now that we have available physical pages to allocate from, we can
|
||||
* build new page tables to replace the bootloader page tables.
|
||||
*/
|
||||
build_page_tables(header, physical_address_limit);
|
||||
|
||||
/*
|
||||
* After we have switched to the newly constructed page tables, we can
|
||||
* iterate through and free the bootloader page tables. They are most
|
||||
* likely already mapped because we just identity mapped every page up
|
||||
* to the physical_address_limit determined above. But just in case the
|
||||
* bootloader used the last pages of RAM for the page table pages, we
|
||||
* will make sure to map them as we traverse them.
|
||||
*/
|
||||
size_t reclaimed_bootloader_page_table_memory = reclaim_bootloader_page_table_pages(bootloader_pt_base) << 10u;
|
||||
usable_memory += reclaimed_bootloader_page_table_memory;
|
||||
|
||||
usable_memory += LinkerAddresses.hulk_bss_size;
|
||||
usable_memory += header.stack_size;
|
||||
usable_memory += fb_size;
|
||||
klog.writefln("Usable memory: %uKB", usable_memory >> 10u);
|
||||
klog.writefln("Kernel size: %uKB", (LinkerAddresses.hulk_binary_size + LinkerAddresses.hulk_bss_size + header.stack_size) >> 10u);
|
||||
}
|
||||
|
||||
public static void map(T, U)(T virtual, U physical, ulong flags)
|
||||
{
|
||||
PageTable * pt = m_pt_base;
|
||||
for (size_t level = 0; level < 4u; level++)
|
||||
{
|
||||
PageTableEntry * ppte = pt.entry(virtual, level);
|
||||
if (level < 3u)
|
||||
{
|
||||
PageTableEntry pte = *ppte;
|
||||
if (pte.present)
|
||||
{
|
||||
pt = pte.follow();
|
||||
}
|
||||
else
|
||||
{
|
||||
PageTable * next_pt = allocate_pt();
|
||||
*ppte = PageTableEntry(next_pt, PT_WRITABLE | PT_PRESENT);
|
||||
pt = next_pt;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
*ppte = PageTableEntry(cast(ulong)physical, flags | PT_PRESENT);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void map_range(size_t virtual, size_t physical, size_t length, ulong flags)
|
||||
{
|
||||
size_t end = virtual + length;
|
||||
while (virtual < end)
|
||||
{
|
||||
map(virtual, physical, flags);
|
||||
virtual += PAGE_SIZE;
|
||||
physical += PAGE_SIZE;
|
||||
}
|
||||
}
|
||||
|
||||
public static void identity_map_range(size_t address, size_t length, ulong flags)
|
||||
{
|
||||
size_t end = address + length;
|
||||
for (size_t page = address & ~0xFFFu; page < end; page += PAGE_SIZE)
|
||||
{
|
||||
map(page, page, flags);
|
||||
}
|
||||
}
|
||||
|
||||
public static void debug_lookup(void * address)
|
||||
{
|
||||
klog.writefln("Debugging page table lookup of 0x%x", address);
|
||||
PageTable * pt = m_pt_base;
|
||||
for (size_t level = 0; level < 4u; level++)
|
||||
{
|
||||
PageTableEntry pte = *pt.entry(address, level);
|
||||
klog.writefln("Level %u, index %u, entry = 0x%x", level, pt.index(address, level), pte);
|
||||
if (pte.present)
|
||||
{
|
||||
pt = pte.follow();
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
if (pte.huge)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static PageTable * allocate_pt()
|
||||
{
|
||||
PageTable * pt = cast(PageTable *)hippo.allocate_page();
|
||||
memset64(pt, 0u, PAGE_SIZE / 8u);
|
||||
return pt;
|
||||
}
|
||||
}
|
||||
128
src/hulk/idt.d
128
src/hulk/idt.d
@ -1,128 +0,0 @@
|
||||
/**
|
||||
* IDT (Interrupt Descriptor Table) functionality.
|
||||
*/
|
||||
module hulk.idt;
|
||||
|
||||
import hulk.gdt;
|
||||
import ldc.llvmasm;
|
||||
import hulk.fb;
|
||||
import hulk.console;
|
||||
import hulk.klog;
|
||||
import hulk.apic;
|
||||
import hulk.rtc;
|
||||
|
||||
struct idt
|
||||
{
|
||||
/* The I/O APIC is configured to map IRQ 0 to interrupt 64 (0x40). */
|
||||
public static enum ulong INT_RTC = 0x48u; /* IRQ 8 */
|
||||
|
||||
public static enum ulong INT_LAPIC_TIMER = 0x70u;
|
||||
public static enum ulong INT_LAPIC_LINT0 = 0x71u;
|
||||
public static enum ulong INT_LAPIC_LINT1 = 0x72u;
|
||||
|
||||
struct idtr_t
|
||||
{
|
||||
ushort limit;
|
||||
align(2) ulong offset;
|
||||
}
|
||||
static assert(idtr_t.sizeof == 10u);
|
||||
|
||||
alias descriptor_t = ulong[2];
|
||||
|
||||
static __gshared align(0x10) descriptor_t[256] idt;
|
||||
static assert(idt.sizeof == (256u * 16u));
|
||||
static __gshared idtr_t idtr;
|
||||
|
||||
public static void initialize()
|
||||
{
|
||||
set_isrs();
|
||||
idtr.limit = idt.sizeof - 1u;
|
||||
idtr.offset = cast(ulong)&idt;
|
||||
lidt(&idtr);
|
||||
}
|
||||
|
||||
private static void lidt(idtr_t * idtr)
|
||||
{
|
||||
__asm("lidt $0", "*m", idtr);
|
||||
}
|
||||
|
||||
private static bool isr_has_error_code(size_t isr)
|
||||
{
|
||||
return (isr == 8) ||
|
||||
((10 <= isr) && (isr <= 14)) ||
|
||||
(isr == 17) ||
|
||||
(isr == 21) ||
|
||||
(isr == 29) ||
|
||||
(isr == 30);
|
||||
}
|
||||
|
||||
private static bool isr_is_trap(size_t isr)
|
||||
{
|
||||
return (isr < 32u) && (isr != 2u);
|
||||
}
|
||||
|
||||
private static void set_isrs()
|
||||
{
|
||||
ulong isr_address;
|
||||
static foreach(isr; 0 .. 256)
|
||||
{
|
||||
mixin("isr_address = __asm!ulong(`
|
||||
movabs $$1f, %rax
|
||||
jmp 2f
|
||||
1:
|
||||
pushq %rdi
|
||||
pushq %rsi
|
||||
pushq %rax
|
||||
mov $$", isr, ", %rdi
|
||||
" ~ (isr_has_error_code(isr) ? "mov 0x18(%rsp), %rsi" : "") ~ "
|
||||
movabs $$isr, %rax
|
||||
callq *%rax
|
||||
popq %rax
|
||||
popq %rsi
|
||||
popq %rdi
|
||||
" ~ (isr_has_error_code(isr) ? "add $$8, %rsp" : "") ~ "
|
||||
iretq
|
||||
2:`, `={rax}`);");
|
||||
mixin("set_descriptor(", isr, ", 0u, " ~
|
||||
(isr_is_trap(isr) ? "true" : "false") ~ ", isr_address);");
|
||||
}
|
||||
}
|
||||
|
||||
private static void set_descriptor(size_t index, ulong dpl, bool trap, ulong offset)
|
||||
{
|
||||
idt[index][0] =
|
||||
0x0000_8E_00_0000_0000u |
|
||||
((offset & 0xFFFF_0000u) << 32u) |
|
||||
(dpl << 45u) |
|
||||
((trap ? 1uL : 0uL) << 40u) |
|
||||
(gdt.SELECTOR_KERNEL_CODE << 16u) |
|
||||
(offset & 0xFFFFu);
|
||||
idt[index][1] = offset >> 32u;
|
||||
}
|
||||
}
|
||||
|
||||
public extern(C) void isr(ulong vector, ulong arg)
|
||||
{
|
||||
switch (vector)
|
||||
{
|
||||
case idt.INT_RTC:
|
||||
rtc.isr();
|
||||
break;
|
||||
|
||||
case idt.INT_LAPIC_TIMER:
|
||||
case idt.INT_LAPIC_LINT0:
|
||||
case idt.INT_LAPIC_LINT1:
|
||||
apic.isr(vector);
|
||||
break;
|
||||
|
||||
default:
|
||||
console.clear();
|
||||
fb.clear(0xFF8000u);
|
||||
klog.writefln("ISR %u, 0x%x", vector, arg);
|
||||
__asm("cli", "");
|
||||
for (;;)
|
||||
{
|
||||
__asm("hlt", "");
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,73 +0,0 @@
|
||||
/**
|
||||
* HULK Kernel Log buffer.
|
||||
*/
|
||||
module hulk.klog;
|
||||
|
||||
import core.stdc.stdarg;
|
||||
import hulk.console;
|
||||
static import hulk.writef;
|
||||
|
||||
struct klog
|
||||
{
|
||||
/**
|
||||
* Kernel buffer size log.
|
||||
* 16 gives a kernel buffer size of 64KB.
|
||||
*/
|
||||
private enum size_t KLOG_SIZE_LOG = 16u;
|
||||
|
||||
/** Kernel buffer size. */
|
||||
private enum size_t KLOG_SIZE = 1u << KLOG_SIZE_LOG;
|
||||
|
||||
/** Kernel log buffer. */
|
||||
private static __gshared align(4096) ubyte[KLOG_SIZE] klog_buffer;
|
||||
|
||||
/** Write index in the kernel log buffer. */
|
||||
private static __gshared size_t klog_index;
|
||||
|
||||
/**
|
||||
* Initialize the klog module.
|
||||
*/
|
||||
public static void initialize()
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a formatted string to the kernel log.
|
||||
*
|
||||
* @param s Format string.
|
||||
* @param args Variable arguments structure.
|
||||
*/
|
||||
public static void writef(string s, va_list args)
|
||||
{
|
||||
hulk.writef.writef(s, args, function void(ubyte ch) {
|
||||
console.write(ch);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a formatted string to the kernel log.
|
||||
*
|
||||
* @param s Format string.
|
||||
*/
|
||||
public static extern (C) void writef(string s, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, s);
|
||||
writef(s, args);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
/**
|
||||
* Write a formatted string and newline to the console.
|
||||
*
|
||||
* @param s Format string.
|
||||
*/
|
||||
public static extern (C) void writefln(string s, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, s);
|
||||
writef(s, args);
|
||||
writef("\n", args);
|
||||
va_end(args);
|
||||
}
|
||||
}
|
||||
@ -1,139 +0,0 @@
|
||||
/**
|
||||
* This module provides access to linker-defined symbols.
|
||||
*/
|
||||
module hulk.linker_addresses;
|
||||
|
||||
private extern extern(C) __gshared ubyte _hulk_header_start;
|
||||
private extern extern(C) __gshared ubyte _hulk_header_end;
|
||||
private extern extern(C) __gshared ubyte _hulk_header_size;
|
||||
|
||||
private extern extern(C) __gshared ubyte _hulk_text_start;
|
||||
private extern extern(C) __gshared ubyte _hulk_text_end;
|
||||
private extern extern(C) __gshared ubyte _hulk_text_size;
|
||||
|
||||
private extern extern(C) __gshared ubyte _hulk_rodata_start;
|
||||
private extern extern(C) __gshared ubyte _hulk_rodata_end;
|
||||
private extern extern(C) __gshared ubyte _hulk_rodata_size;
|
||||
|
||||
private extern extern(C) __gshared ubyte _hulk_data_start;
|
||||
private extern extern(C) __gshared ubyte _hulk_data_end;
|
||||
private extern extern(C) __gshared ubyte _hulk_data_size;
|
||||
|
||||
private extern extern(C) __gshared ubyte _hulk_bss_start;
|
||||
private extern extern(C) __gshared ubyte _hulk_bss_end;
|
||||
private extern extern(C) __gshared ubyte _hulk_bss_size;
|
||||
|
||||
/* hulk_binary includes header, text, rodata, and data */
|
||||
private extern extern(C) __gshared ubyte _hulk_binary_size;
|
||||
|
||||
/* hulk_mem includes header, text, rodata, data, and bss */
|
||||
private extern extern(C) __gshared ubyte _hulk_mem_start;
|
||||
private extern extern(C) __gshared ubyte _hulk_mem_end;
|
||||
private extern extern(C) __gshared ubyte _hulk_mem_size;
|
||||
|
||||
/**
|
||||
* This struct provides access to linker-defined symbols.
|
||||
*/
|
||||
public struct LinkerAddresses
|
||||
{
|
||||
public static @property ulong hulk_header_start()
|
||||
{
|
||||
return cast(ulong)&_hulk_header_start;
|
||||
}
|
||||
|
||||
public static @property ulong hulk_header_end()
|
||||
{
|
||||
return cast(ulong)&_hulk_header_end;
|
||||
}
|
||||
|
||||
public static @property ulong hulk_header_size()
|
||||
{
|
||||
return cast(ulong)&_hulk_header_size;
|
||||
}
|
||||
|
||||
|
||||
public static @property ulong hulk_text_start()
|
||||
{
|
||||
return cast(ulong)&_hulk_text_start;
|
||||
}
|
||||
|
||||
public static @property ulong hulk_text_end()
|
||||
{
|
||||
return cast(ulong)&_hulk_text_end;
|
||||
}
|
||||
|
||||
public static @property ulong hulk_text_size()
|
||||
{
|
||||
return cast(ulong)&_hulk_text_size;
|
||||
}
|
||||
|
||||
|
||||
public static @property ulong hulk_rodata_start()
|
||||
{
|
||||
return cast(ulong)&_hulk_rodata_start;
|
||||
}
|
||||
|
||||
public static @property ulong hulk_rodata_end()
|
||||
{
|
||||
return cast(ulong)&_hulk_rodata_end;
|
||||
}
|
||||
|
||||
public static @property ulong hulk_rodata_size()
|
||||
{
|
||||
return cast(ulong)&_hulk_rodata_size;
|
||||
}
|
||||
|
||||
|
||||
public static @property ulong hulk_data_start()
|
||||
{
|
||||
return cast(ulong)&_hulk_data_start;
|
||||
}
|
||||
|
||||
public static @property ulong hulk_data_end()
|
||||
{
|
||||
return cast(ulong)&_hulk_data_end;
|
||||
}
|
||||
|
||||
public static @property ulong hulk_data_size()
|
||||
{
|
||||
return cast(ulong)&_hulk_data_size;
|
||||
}
|
||||
|
||||
|
||||
public static @property ulong hulk_bss_start()
|
||||
{
|
||||
return cast(ulong)&_hulk_bss_start;
|
||||
}
|
||||
|
||||
public static @property ulong hulk_bss_end()
|
||||
{
|
||||
return cast(ulong)&_hulk_bss_end;
|
||||
}
|
||||
|
||||
public static @property ulong hulk_bss_size()
|
||||
{
|
||||
return cast(ulong)&_hulk_bss_size;
|
||||
}
|
||||
|
||||
|
||||
public static @property ulong hulk_binary_size()
|
||||
{
|
||||
return cast(ulong)&_hulk_binary_size;
|
||||
}
|
||||
|
||||
|
||||
public static @property ulong hulk_mem_start()
|
||||
{
|
||||
return cast(ulong)&_hulk_mem_start;
|
||||
}
|
||||
|
||||
public static @property ulong hulk_mem_end()
|
||||
{
|
||||
return cast(ulong)&_hulk_mem_end;
|
||||
}
|
||||
|
||||
public static @property ulong hulk_mem_size()
|
||||
{
|
||||
return cast(ulong)&_hulk_mem_size;
|
||||
}
|
||||
}
|
||||
@ -1,62 +0,0 @@
|
||||
/**
|
||||
* Memory-related functions.
|
||||
*/
|
||||
module hulk.memory;
|
||||
|
||||
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, const(void) * src, size_t n)
|
||||
{
|
||||
__asm("rep movsb",
|
||||
"{rcx},{rsi},{rdi},~{rcx},~{rsi},~{rdi},~{memory}",
|
||||
n, src, dest);
|
||||
}
|
||||
|
||||
void memcpy16(void * dest, const(void) * src, size_t n)
|
||||
{
|
||||
__asm("rep movsw",
|
||||
"{rcx},{rsi},{rdi},~{rcx},~{rsi},~{rdi},~{memory}",
|
||||
n, src, dest);
|
||||
}
|
||||
|
||||
void memcpy32(void * dest, const(void) * src, size_t n)
|
||||
{
|
||||
__asm("rep movsl",
|
||||
"{rcx},{rsi},{rdi},~{rcx},~{rsi},~{rdi},~{memory}",
|
||||
n, src, dest);
|
||||
}
|
||||
|
||||
void memcpy64(void * dest, const(void) * src, size_t n)
|
||||
{
|
||||
__asm("rep movsq",
|
||||
"{rcx},{rsi},{rdi},~{rcx},~{rsi},~{rdi},~{memory}",
|
||||
n, src, dest);
|
||||
}
|
||||
@ -1,70 +0,0 @@
|
||||
/**
|
||||
* MTRR (Memory Type Range Register) support for HULK.
|
||||
*/
|
||||
module hulk.mtrr;
|
||||
|
||||
import hulk.cpu;
|
||||
import hulk.klog;
|
||||
|
||||
enum ulong MTRR_TYPE_UC = 0u; /* Uncacheable */
|
||||
enum ulong MTRR_TYPE_WC = 1u; /* Write-Combining */
|
||||
enum ulong MTRR_TYPE_WT = 4u; /* Writethrough */
|
||||
enum ulong MTRR_TYPE_WP = 5u; /* Write-Protect */
|
||||
enum ulong MTRR_TYPE_WB = 6u; /* Writeback */
|
||||
|
||||
enum uint MSR_MTRRCAP = 0xFEu;
|
||||
enum uint MSR_MTRRDEFTYPE = 0x2FFu;
|
||||
enum uint MSR_MTRRPHYSBASE0 = 0x200u;
|
||||
enum uint MSR_MTRRPHYSMASK0 = 0x201u;
|
||||
|
||||
enum ulong MTRRCAP_WC = 0x400u;
|
||||
enum ulong MTRRCAP_FIX = 0x100u;
|
||||
enum ulong MTRRCAP_VCNT_MASK = 0xFFu;
|
||||
|
||||
enum ulong MTRRDEFTYPE_E = 0x800u;
|
||||
enum ulong MTRRDEFTYPE_FE = 0x400u;
|
||||
enum ulong MTRRDEFTYPE_TYPE_MASK = 0xFFu;
|
||||
|
||||
enum ulong MTRRPHYSBASE_PHYSBASE_MASK = 0x000F_FFFF_FFFF_F000u;
|
||||
enum ulong MTRRPHYSBASE_TYPE_MASK = 0xFFu;
|
||||
|
||||
enum ulong MTRRPHYSMASK_PHYSMASK_MASK = 0x000F_FFFF_FFFF_F000u;
|
||||
enum ulong MTRRPHYSMASK_VALID = 0x800u;
|
||||
|
||||
struct mtrr
|
||||
{
|
||||
public static void initialize()
|
||||
{
|
||||
uint ebx;
|
||||
uint ecx;
|
||||
uint edx;
|
||||
cpuid1(&ebx, &ecx, &edx);
|
||||
if ((edx & CPUID_1_EDX_MTRR) == 0u)
|
||||
{
|
||||
klog.writefln("CPU does not support MTRR");
|
||||
return;
|
||||
}
|
||||
const(ulong) mtrrcap = rdmsr(MSR_MTRRCAP);
|
||||
const(ulong) mtrrdeftype = rdmsr(MSR_MTRRDEFTYPE);
|
||||
}
|
||||
|
||||
private static ulong get_phys_base(uint n)
|
||||
{
|
||||
return rdmsr(MSR_MTRRPHYSBASE0 + 2u * n);
|
||||
}
|
||||
|
||||
private static void set_phys_base(uint n, ulong physbase)
|
||||
{
|
||||
wrmsr(MSR_MTRRPHYSBASE0 + 2u * n, physbase);
|
||||
}
|
||||
|
||||
private static ulong get_phys_mask(uint n)
|
||||
{
|
||||
return rdmsr(MSR_MTRRPHYSMASK0 + 2u * n);
|
||||
}
|
||||
|
||||
private static void set_phys_mask(uint n, ulong physmask)
|
||||
{
|
||||
wrmsr(MSR_MTRRPHYSMASK0 + 2u * n, physmask);
|
||||
}
|
||||
}
|
||||
@ -1,185 +0,0 @@
|
||||
/**
|
||||
* Page table structures.
|
||||
*/
|
||||
module hulk.pagetable;
|
||||
|
||||
/** Page table entry attributes. @{ */
|
||||
enum ulong PT_PRESENT = 0x1u;
|
||||
enum ulong PT_WRITABLE = 0x2u;
|
||||
enum ulong PT_USER = 0x4u;
|
||||
enum ulong PT_WRITE_THROUGH = 0x8u;
|
||||
enum ulong PT_DISABLE_CACHE = 0x10u;
|
||||
enum ulong PT_ACCESSED = 0x20u;
|
||||
enum ulong PT_DIRTY = 0x40u;
|
||||
enum ulong PT_HUGE_PAGE = 0x80u;
|
||||
enum ulong PT_GLOBAL = 0x100u;
|
||||
enum ulong PT_NO_EXECUTE = 0x8000_0000_0000_0000u;
|
||||
/** @} */
|
||||
|
||||
/** Page size in bytes. */
|
||||
enum ulong PAGE_SIZE = 4096u;
|
||||
|
||||
/**
|
||||
* Structure that represents a page table entry.
|
||||
*/
|
||||
struct PageTableEntry
|
||||
{
|
||||
/** The raw page table entry is a 64-bit ulong. */
|
||||
public ulong entry;
|
||||
alias entry this;
|
||||
|
||||
/**
|
||||
* Construct a page table entry.
|
||||
*
|
||||
* @param address
|
||||
* Address pointed to by the page table entry (ulong or pointer).
|
||||
* @param flags
|
||||
* Page table flags (ORed set of PT_*).
|
||||
*/
|
||||
this(T)(T address, ulong flags = 0u)
|
||||
{
|
||||
entry = cast(ulong)address | flags;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whether the page is present.
|
||||
*/
|
||||
public @property bool present() const
|
||||
{
|
||||
return (entry & PT_PRESENT) != 0u;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whether the page is writable.
|
||||
*/
|
||||
public @property bool writable() const
|
||||
{
|
||||
return (entry & PT_WRITABLE) != 0u;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whether the page is a user page.
|
||||
*/
|
||||
public @property bool user() const
|
||||
{
|
||||
return (entry & PT_USER) != 0u;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whether the page is write-through.
|
||||
*/
|
||||
public @property bool write_through() const
|
||||
{
|
||||
return (entry & PT_WRITE_THROUGH) != 0u;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whether the page has disable cache set.
|
||||
*/
|
||||
public @property bool disable_cache() const
|
||||
{
|
||||
return (entry & PT_DISABLE_CACHE) != 0u;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whether the page is huge.
|
||||
*/
|
||||
public @property bool huge() const
|
||||
{
|
||||
return (entry & PT_HUGE_PAGE) != 0u;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whether the page is global.
|
||||
*/
|
||||
public @property bool global() const
|
||||
{
|
||||
return (entry & PT_GLOBAL) != 0u;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whether the page is no-execute.
|
||||
*/
|
||||
public @property bool no_execute() const
|
||||
{
|
||||
return (entry & PT_NO_EXECUTE) != 0u;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whether the page is dirty.
|
||||
*/
|
||||
public @property bool dirty() const
|
||||
{
|
||||
return (entry & PT_DIRTY) != 0u;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return whether the page is accessed.
|
||||
*/
|
||||
public @property bool accessed() const
|
||||
{
|
||||
return (entry & PT_ACCESSED) != 0u;
|
||||
}
|
||||
|
||||
/**
|
||||
* Follow the page table entry to the next page table it points to.
|
||||
*/
|
||||
public PageTable * follow() const
|
||||
{
|
||||
return cast(PageTable *)(entry & 0x7FFF_FFFF_FFFF_F000u);
|
||||
}
|
||||
}
|
||||
static assert(PageTableEntry.sizeof == 8u);
|
||||
|
||||
/**
|
||||
* Structure that represents a page table.
|
||||
*/
|
||||
struct PageTable
|
||||
{
|
||||
/** Number of page table entries in a page table. */
|
||||
enum size_t N_ENTRIES = 512u;
|
||||
|
||||
/** Page table entries. */
|
||||
private PageTableEntry[N_ENTRIES] entries;
|
||||
|
||||
/**
|
||||
* Access the PageTableEntry for the given address and page table level.
|
||||
*
|
||||
* @param address
|
||||
* Address to look up the page table entry (ulong or pointer).
|
||||
* @param level
|
||||
* Page table level (0-4).
|
||||
*/
|
||||
public PageTableEntry * entry(T)(T address, ulong level)
|
||||
{
|
||||
return &entries[index(cast(ulong)address, level)];
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine the index into the page table for the given address and page
|
||||
* table level.
|
||||
*
|
||||
* @param address
|
||||
* Address to look up the page table entry (ulong or pointer).
|
||||
* @param level
|
||||
* Page table level (0-4).
|
||||
*/
|
||||
public ulong index(T)(T address, ulong level)
|
||||
{
|
||||
return (cast(ulong)address >> (39u - (9u * level))) & 0x1FFu;
|
||||
}
|
||||
|
||||
/**
|
||||
* Access a page table entry by linear index.
|
||||
*
|
||||
* @param index
|
||||
* Page table index (0-511).
|
||||
*
|
||||
* @return PageTableEntry at the given index.
|
||||
*/
|
||||
public PageTableEntry opIndex(size_t index)
|
||||
{
|
||||
return entries[index];
|
||||
}
|
||||
}
|
||||
static assert(PageTable.sizeof == 4096u);
|
||||
@ -1,48 +0,0 @@
|
||||
module hulk.pci;
|
||||
|
||||
import hulk.cpu;
|
||||
import hulk.klog;
|
||||
|
||||
struct pci
|
||||
{
|
||||
/* IO address for PCI configuration address. */
|
||||
enum IO_ADDR_CONFIG_ADDRESS = 0xCF8u;
|
||||
|
||||
/* IO address for PCI configuration data. */
|
||||
enum IO_ADDR_CONFIG_DATA = 0xCFCu;
|
||||
|
||||
private static ulong read_config_register(ulong bus_id, ulong device_id, ulong register_id)
|
||||
{
|
||||
ulong addr = 0x8000_0000u | (bus_id << 16u) | (device_id << 11u) | (register_id << 2u);
|
||||
out32(IO_ADDR_CONFIG_ADDRESS, addr);
|
||||
return in32(IO_ADDR_CONFIG_DATA);
|
||||
}
|
||||
|
||||
private static void scan(ulong bus_id, ulong device_id)
|
||||
{
|
||||
ulong reg0 = read_config_register(bus_id, device_id, 0u);
|
||||
if (reg0 != 0xFFFFFFFFu)
|
||||
{
|
||||
ulong reg2 = read_config_register(bus_id, device_id, 2u);
|
||||
klog.writefln("Found PCI device %04x:%04x (%02x:%02x:%02x) at %02u:%02u",
|
||||
(reg0 & 0xFFFFu), (reg0 >> 16u),
|
||||
(reg2 >> 24u) & 0xFFu,
|
||||
(reg2 >> 16u) & 0xFFu,
|
||||
(reg2 >> 8u) & 0xFFu,
|
||||
bus_id, device_id);
|
||||
}
|
||||
}
|
||||
|
||||
public static void initialize()
|
||||
{
|
||||
klog.writefln("Scanning PCI devices...");
|
||||
for (ulong bus_id = 0u; bus_id < 256u; bus_id++)
|
||||
{
|
||||
for (ulong device_id = 0u; device_id < 32u; device_id++)
|
||||
{
|
||||
scan(bus_id, device_id);
|
||||
}
|
||||
}
|
||||
klog.writefln("PCI scan complete.");
|
||||
}
|
||||
}
|
||||
@ -1,16 +0,0 @@
|
||||
/**
|
||||
* PIC (Programmable Interrupt Controller) functionality.
|
||||
*/
|
||||
module hulk.pic;
|
||||
|
||||
import hulk.cpu;
|
||||
|
||||
struct pic
|
||||
{
|
||||
public static void initialize()
|
||||
{
|
||||
/* Disable the PIC. */
|
||||
out8(0xA1u, 0xFFu);
|
||||
out8(0x21u, 0xFFu);
|
||||
}
|
||||
}
|
||||
@ -1,42 +0,0 @@
|
||||
/**
|
||||
* PIT (Programmable Interval Timer) functionality.
|
||||
*/
|
||||
module hulk.pit;
|
||||
|
||||
import hulk.cpu;
|
||||
import hulk.klog;
|
||||
|
||||
struct pit
|
||||
{
|
||||
/** PIT input frequency in 1/1000 Hz. */
|
||||
private enum ulong PIT_FREQUENCY_1000HZ = 1_193_181_667u;
|
||||
private enum ulong TARGET_INTERRUPT_HZ = 100u;
|
||||
private enum ulong TARGET_INTERRUPT_1000HZ = TARGET_INTERRUPT_HZ * 1000u;
|
||||
private enum ulong PIT_DIVIDER = (PIT_FREQUENCY_1000HZ + TARGET_INTERRUPT_1000HZ / 2u) / TARGET_INTERRUPT_1000HZ;
|
||||
|
||||
/** PIT channel 0 I/O port. */
|
||||
private enum ubyte PORT_CH_0 = 0x40u;
|
||||
/** PIT channel 1 I/O port. */
|
||||
private enum ubyte PORT_CH_1 = 0x41u;
|
||||
/** PIT channel 2 I/O port. */
|
||||
private enum ubyte PORT_CH_2 = 0x42u;
|
||||
/** PIT mode/command register I/O port. */
|
||||
private enum ubyte PORT_MC = 0x43u;
|
||||
|
||||
private enum ubyte MC_CH_0 = 0x00u;
|
||||
private enum ubyte MC_LO_HI = 0x30u;
|
||||
private enum ubyte MC_RATE_GENERATOR = 0x04u;
|
||||
private enum ubyte MC_BINARY = 0x00u;
|
||||
|
||||
public static void initialize()
|
||||
{
|
||||
out8(PORT_MC, MC_CH_0 | MC_LO_HI | MC_RATE_GENERATOR | MC_BINARY);
|
||||
out8(PORT_CH_0, PIT_DIVIDER & 0xFFu);
|
||||
out8(PORT_CH_0, PIT_DIVIDER >> 8u);
|
||||
}
|
||||
|
||||
public static void isr()
|
||||
{
|
||||
klog.writefln("PIT ISR");
|
||||
}
|
||||
}
|
||||
@ -1,58 +0,0 @@
|
||||
/**
|
||||
* RTC (Real-Time Clock) functionality.
|
||||
*/
|
||||
module hulk.rtc;
|
||||
|
||||
import hulk.cpu;
|
||||
import hulk.klog;
|
||||
import hulk.apic;
|
||||
|
||||
struct rtc
|
||||
{
|
||||
private enum ubyte PORT_SELECT = 0x70u;
|
||||
private enum ubyte PORT_DATA = 0x71u;
|
||||
|
||||
private enum ubyte DISABLE_NMI = 0x80u;
|
||||
|
||||
private enum ubyte SR_A = 0xAu;
|
||||
private enum ubyte SR_B = 0xBu;
|
||||
private enum ubyte SR_C = 0xCu;
|
||||
|
||||
private enum ubyte SR_B_ENABLE_IRQ = 0x40u;
|
||||
|
||||
public static void initialize()
|
||||
{
|
||||
/* Enable IRQ 8 to receive RTC interrupts. */
|
||||
out8(PORT_SELECT, DISABLE_NMI | SR_B);
|
||||
ubyte sr_b = in8(PORT_DATA);
|
||||
out8(PORT_SELECT, DISABLE_NMI | SR_B);
|
||||
out8(PORT_DATA, sr_b | SR_B_ENABLE_IRQ);
|
||||
|
||||
out8(PORT_SELECT, DISABLE_NMI | SR_A);
|
||||
klog.writefln("SR_A = 0x%x", in8(PORT_DATA));
|
||||
|
||||
/* Send EOI to enable more RTC interrupts and re-enable NMIs. */
|
||||
eoi();
|
||||
}
|
||||
|
||||
private static void eoi()
|
||||
{
|
||||
/* Read from status register C to clear the interrupt. */
|
||||
out8(PORT_SELECT, SR_C);
|
||||
in8(PORT_DATA);
|
||||
}
|
||||
|
||||
public static void isr()
|
||||
{
|
||||
static __gshared ulong count;
|
||||
static __gshared ulong seconds;
|
||||
count++;
|
||||
if ((count % 1024) == 0u)
|
||||
{
|
||||
seconds++;
|
||||
klog.writefln("Seconds: %u", seconds);
|
||||
}
|
||||
eoi();
|
||||
apic.eoi();
|
||||
}
|
||||
}
|
||||
@ -1,151 +0,0 @@
|
||||
/**
|
||||
* HULK Formatted stream writing support.
|
||||
*/
|
||||
module hulk.writef;
|
||||
|
||||
import core.stdc.stdarg;
|
||||
|
||||
alias ch_out_fn = void function(ubyte);
|
||||
|
||||
/**
|
||||
* Format a string and write characters to the given output function.
|
||||
*
|
||||
* @param s Format string.
|
||||
* @param args Variable arguments structure.
|
||||
* @param ch_out Character output function.
|
||||
*
|
||||
* @return Number of characters written.
|
||||
*/
|
||||
size_t writef(string s, va_list args, ch_out_fn ch_out)
|
||||
{
|
||||
size_t length_written;
|
||||
bool escape = false;
|
||||
char pad = ' ';
|
||||
size_t width;
|
||||
foreach (char c; s)
|
||||
{
|
||||
if (escape)
|
||||
{
|
||||
if (c == 'x')
|
||||
{
|
||||
ulong v;
|
||||
va_arg(args, v);
|
||||
length_written += write_hex(v, false, pad, width, ch_out);
|
||||
escape = false;
|
||||
}
|
||||
else if (c == 'X')
|
||||
{
|
||||
ulong v;
|
||||
va_arg(args, v);
|
||||
length_written += write_hex(v, true, pad, width, ch_out);
|
||||
escape = false;
|
||||
}
|
||||
else if (c == 'u')
|
||||
{
|
||||
ulong v;
|
||||
va_arg(args, v);
|
||||
length_written += write_udec(v, pad, width, ch_out);
|
||||
escape = false;
|
||||
}
|
||||
else if ((c == '0') && (width == 0u))
|
||||
{
|
||||
pad = '0';
|
||||
}
|
||||
else if (('0' <= c) && (c <= '9'))
|
||||
{
|
||||
width = (width * 10u) + (c - '0');
|
||||
}
|
||||
else
|
||||
{
|
||||
ch_out(c);
|
||||
escape = false;
|
||||
}
|
||||
}
|
||||
else if (c == '%')
|
||||
{
|
||||
escape = true;
|
||||
pad = ' ';
|
||||
width = 0u;
|
||||
}
|
||||
else
|
||||
{
|
||||
ch_out(c);
|
||||
}
|
||||
}
|
||||
return length_written;
|
||||
}
|
||||
|
||||
/**
|
||||
* Format a value in hexadecimal to the given output function.
|
||||
*
|
||||
* @param v Value to format.
|
||||
* @param upper Whether to use uppercase letters.
|
||||
* @param pad Pad character to use.
|
||||
* @param width Field width.
|
||||
* @param ch_out Character output function.
|
||||
*
|
||||
* @return Number of characters written.
|
||||
*/
|
||||
private size_t write_hex(ulong v, bool upper, char pad, size_t width, ch_out_fn ch_out)
|
||||
{
|
||||
static __gshared const(char)[16] hex_chars_lower = "0123456789abcdef";
|
||||
static __gshared const(char)[16] hex_chars_upper = "0123456789ABCDEF";
|
||||
char[16] buf;
|
||||
size_t i;
|
||||
do
|
||||
{
|
||||
ulong n = v & 0xFu;
|
||||
buf[i] = upper ? hex_chars_upper[n] : hex_chars_lower[n];
|
||||
v >>= 4u;
|
||||
i++;
|
||||
} while (v != 0u);
|
||||
size_t length_written = i;
|
||||
while (width > i)
|
||||
{
|
||||
ch_out(pad);
|
||||
width--;
|
||||
length_written++;
|
||||
}
|
||||
do
|
||||
{
|
||||
i--;
|
||||
ch_out(buf[i]);
|
||||
} while (i != 0u);
|
||||
return length_written;
|
||||
}
|
||||
|
||||
/**
|
||||
* Format a value in decimal to the given output function.
|
||||
*
|
||||
* @param v Value to format.
|
||||
* @param pad Pad character to use.
|
||||
* @param width Field width.
|
||||
* @param ch_out Character output function.
|
||||
*
|
||||
* @return Number of characters written.
|
||||
*/
|
||||
private size_t write_udec(ulong v, char pad, size_t width, ch_out_fn ch_out)
|
||||
{
|
||||
char[20] buf;
|
||||
size_t i;
|
||||
do
|
||||
{
|
||||
ulong d = v % 10u;
|
||||
buf[i] = cast(char)(d + '0');
|
||||
v /= 10u;
|
||||
i++;
|
||||
} while (v != 0u);
|
||||
size_t length_written = i;
|
||||
while (width > i)
|
||||
{
|
||||
ch_out(pad);
|
||||
width--;
|
||||
length_written++;
|
||||
}
|
||||
do
|
||||
{
|
||||
i--;
|
||||
ch_out(buf[i]);
|
||||
} while (i != 0u);
|
||||
return length_written;
|
||||
}
|
||||
103
src/klog.c
Normal file
103
src/klog.c
Normal file
@ -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);
|
||||
}
|
||||
7
src/klog.h
Normal file
7
src/klog.h
Normal file
@ -0,0 +1,7 @@
|
||||
#ifndef KLOG_H
|
||||
#define KLOG_H
|
||||
|
||||
void klog_init(void);
|
||||
void klog_printf(const char * fmt, ...);
|
||||
|
||||
#endif
|
||||
41
src/link.ld
Normal file
41
src/link.ld
Normal file
@ -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 = .;
|
||||
}
|
||||
100
src/mbinfo.c
Normal file
100
src/mbinfo.c
Normal file
@ -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);
|
||||
}
|
||||
10
src/mbinfo.h
Normal file
10
src/mbinfo.h
Normal file
@ -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
|
||||
49
src/mem.h
Normal file
49
src/mem.h
Normal file
@ -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
|
||||
91
src/mm.c
Normal file
91
src/mm.c
Normal file
@ -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;
|
||||
}
|
||||
25
src/mm.h
Normal file
25
src/mm.h
Normal file
@ -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
|
||||
127
src/multiboot2.h
Normal file
127
src/multiboot2.h
Normal file
@ -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
|
||||
12
src/multiboot_header.c
Normal file
12
src/multiboot_header.c
Normal file
@ -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(),
|
||||
};
|
||||
12
src/stream.h
Normal file
12
src/stream.h
Normal file
@ -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
|
||||
26
src/string.h
Normal file
26
src/string.h
Normal file
@ -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
|
||||
1
uefi-d
1
uefi-d
@ -1 +0,0 @@
|
||||
Subproject commit e70959ce8ad1b113b5f7aa2111ea4d88f6b6ea63
|
||||
Loading…
x
Reference in New Issue
Block a user