wip: initial commit
commit
d43d7caf15
GPG Key ID:
3267C8EBF3F9AFC7
@ -0,0 +1,5 @@
|
||||
*.bin
|
||||
*.iso
|
||||
*.o
|
||||
*.sw*
|
||||
iso/boot/*.bin
|
||||
@ -0,0 +1,45 @@
|
||||
ASFLAGS := --32
|
||||
CXXFLAGS := -m32 -ggdb -g3 -O0 -fno-pic -ffreestanding -fno-rtti -fno-exceptions -std=c++23
|
||||
LDFLAGS := -m32 -static -T link.ld -ffreestanding -nostdlib
|
||||
|
||||
ASFILES := boot.s
|
||||
CXXFILES := gdt.cpp \
|
||||
idt.cpp \
|
||||
memory.cpp \
|
||||
multiboot.cpp \
|
||||
pic.cpp \
|
||||
pit.cpp \
|
||||
tasking.cpp \
|
||||
vgaterminal.cpp \
|
||||
kernel.cpp
|
||||
|
||||
OBJS := $(subst .s,.o,$(ASFILES)) \
|
||||
$(subst .cpp,.o,$(CXXFILES))
|
||||
|
||||
all: myos.iso
|
||||
|
||||
myos.iso: myos.bin iso/boot/grub/grub.cfg
|
||||
@echo " ISO " $@
|
||||
@cp myos.bin iso/boot/
|
||||
@grub-mkrescue -o myos.iso iso/
|
||||
|
||||
myos.bin: $(OBJS) link.ld
|
||||
@echo " LD " $@
|
||||
@g++ $(LDFLAGS) -o $@ $(OBJS)
|
||||
|
||||
%.o: %.s
|
||||
@echo " AS " $<
|
||||
@as $(ASFLAGS) -c $< -o $@
|
||||
|
||||
%.o: %.cpp
|
||||
@echo " CXX " $<
|
||||
@g++ $(CXXFLAGS) -c $< -o $@
|
||||
|
||||
clean:
|
||||
@echo " CLEAN"
|
||||
@rm -f $(OBJS) myos.bin myos.iso
|
||||
|
||||
run: myos.iso
|
||||
@echo " QEMU"
|
||||
@qemu-system-i386 -cdrom $< -monitor stdio -no-reboot -s -S #-d int
|
||||
|
||||
@ -0,0 +1,127 @@
|
||||
/* Declare constants for the multiboot header. */
|
||||
.set MAGIC, 0xE85250D6
|
||||
.set FLAGS, 0x0
|
||||
.set LENGTH, 16
|
||||
.set CHECKSUM, -(MAGIC + FLAGS + LENGTH)
|
||||
|
||||
.section .multiboot2
|
||||
.align 8
|
||||
.int MAGIC
|
||||
.int FLAGS
|
||||
.int LENGTH
|
||||
.int CHECKSUM
|
||||
|
||||
/* info request */
|
||||
.align 8
|
||||
.hword 1, 0
|
||||
.int 12
|
||||
.int 4
|
||||
|
||||
/* end tag */
|
||||
.align 8
|
||||
.hword 0, 0
|
||||
.int 8
|
||||
|
||||
/*
|
||||
The multiboot standard does not define the value of the stack pointer register
|
||||
(esp) and it is up to the kernel to provide a stack. This allocates room for a
|
||||
small stack by creating a symbol at the bottom of it, then allocating 16384
|
||||
bytes for it, and finally creating a symbol at the top. The stack grows
|
||||
downwards on x86. The stack is in its own section so it can be marked nobits,
|
||||
which means the kernel file is smaller because it does not contain an
|
||||
uninitialized stack. The stack on x86 must be 16-byte aligned according to the
|
||||
System V ABI standard and de-facto extensions. The compiler will assume the
|
||||
stack is properly aligned and failure to align the stack will result in
|
||||
undefined behavior.
|
||||
*/
|
||||
.section .bss
|
||||
.align 16
|
||||
stack_bottom:
|
||||
.skip 16384 # 16 KiB
|
||||
stack_top:
|
||||
|
||||
/*
|
||||
The linker script specifies _start as the entry point to the kernel and the
|
||||
bootloader will jump to this position once the kernel has been loaded. It
|
||||
doesn't make sense to return from this function as the bootloader is gone.
|
||||
*/
|
||||
.section .text
|
||||
.global _start
|
||||
.type _start, @function
|
||||
_start:
|
||||
/*
|
||||
The bootloader has loaded us into 32-bit protected mode on a x86
|
||||
machine. Interrupts are disabled. Paging is disabled. The processor
|
||||
state is as defined in the multiboot standard. The kernel has full
|
||||
control of the CPU. The kernel can only make use of hardware features
|
||||
and any code it provides as part of itself. There's no printf
|
||||
function, unless the kernel provides its own <stdio.h> header and a
|
||||
printf implementation. There are no security restrictions, no
|
||||
safeguards, no debugging mechanisms, only what the kernel provides
|
||||
itself. It has absolute and complete power over the
|
||||
machine.
|
||||
*/
|
||||
mov %eax, multiboot_magic
|
||||
mov %ebx, multiboot_ptr
|
||||
|
||||
/*
|
||||
To set up a stack, we set the esp register to point to the top of the
|
||||
stack (as it grows downwards on x86 systems). This is necessarily done
|
||||
in assembly as languages such as C cannot function without a stack.
|
||||
*/
|
||||
mov $stack_top, %esp
|
||||
|
||||
/*
|
||||
This is a good place to initialize crucial processor state before the
|
||||
high-level kernel is entered. It's best to minimize the early
|
||||
environment where crucial features are offline. Note that the
|
||||
processor is not fully initialized yet: Features such as floating
|
||||
point instructions and instruction set extensions are not initialized
|
||||
yet. The GDT should be loaded here. Paging should be enabled here.
|
||||
C++ features such as global constructors and exceptions will require
|
||||
runtime support to work as well.
|
||||
*/
|
||||
mov $__init_array_start, %eax
|
||||
.again:
|
||||
cmp $__init_array_end, %eax
|
||||
je .next
|
||||
push %eax
|
||||
call *(%eax)
|
||||
pop %eax
|
||||
add $0x4, %eax
|
||||
jmp .again
|
||||
|
||||
.next:
|
||||
|
||||
/*
|
||||
Enter the high-level kernel. The ABI requires the stack is 16-byte
|
||||
aligned at the time of the call instruction (which afterwards pushes
|
||||
the return pointer of size 4 bytes). The stack was originally 16-byte
|
||||
aligned above and we've pushed a multiple of 16 bytes to the
|
||||
stack since (pushed 0 bytes so far), so the alignment has thus been
|
||||
preserved and the call is well defined.
|
||||
*/
|
||||
call kernel_main
|
||||
|
||||
/*
|
||||
If the system has nothing more to do, put the computer into an
|
||||
infinite loop. To do that:
|
||||
1) Disable interrupts with cli (clear interrupt enable in eflags).
|
||||
They are already disabled by the bootloader, so this is not needed.
|
||||
Mind that you might later enable interrupts and return from
|
||||
kernel_main (which is sort of nonsensical to do).
|
||||
2) Wait for the next interrupt to arrive with hlt (halt instruction).
|
||||
Since they are disabled, this will lock up the computer.
|
||||
3) Jump to the hlt instruction if it ever wakes up due to a
|
||||
non-maskable interrupt occurring or due to system management mode.
|
||||
*/
|
||||
cli
|
||||
1: hlt
|
||||
jmp 1b
|
||||
|
||||
/*
|
||||
Set the size of the _start symbol to the current location '.' minus its start.
|
||||
This is useful when debugging or when you implement call tracing.
|
||||
*/
|
||||
.size _start, . - _start
|
||||
|
||||
@ -0,0 +1,81 @@
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
|
||||
struct gdt_entry_bits {
|
||||
std::uint32_t limit_low : 16;
|
||||
std::uint32_t base_low : 24;
|
||||
std::uint32_t accessed : 1;
|
||||
std::uint32_t read_write : 1; // readable for code, writable for data
|
||||
std::uint32_t conforming_expand_down : 1; // conforming for code, expand down for data
|
||||
std::uint32_t code : 1; // 1 for code, 0 for data
|
||||
std::uint32_t code_data_segment : 1; // should be 1 for everything but TSS and LDT
|
||||
std::uint32_t DPL : 2; // privilege level
|
||||
std::uint32_t present : 1;
|
||||
std::uint32_t limit_high : 4;
|
||||
std::uint32_t available : 1; // only used in software; has no effect on hardware
|
||||
std::uint32_t long_mode : 1;
|
||||
std::uint32_t big : 1; // 32-bit opcodes for code, uint32_t stack for data
|
||||
std::uint32_t gran : 1; // 1 to use 4k page addressing, 0 for byte addressing
|
||||
std::uint32_t base_high : 8;
|
||||
} __attribute__((packed));
|
||||
|
||||
constinit static const std::array<gdt_entry_bits, 3> gdt {{
|
||||
{},
|
||||
/* kernel_code = */ {
|
||||
.limit_low = 0xFFFF,
|
||||
.base_low = 0x0000,
|
||||
.accessed = 0,
|
||||
.read_write = 1,
|
||||
.conforming_expand_down = 0,
|
||||
.code = 1,
|
||||
.code_data_segment = 1,
|
||||
.DPL = 0,
|
||||
.present = 1,
|
||||
.limit_high = 0xF,
|
||||
.available = 0,
|
||||
.long_mode = 0,
|
||||
.big = 1,
|
||||
.gran = 1,
|
||||
.base_high = 0x00
|
||||
},
|
||||
/* kernel_data = */ {
|
||||
.limit_low = 0xFFFF,
|
||||
.base_low = 0x0000,
|
||||
.accessed = 0,
|
||||
.read_write = 1,
|
||||
.conforming_expand_down = 0,
|
||||
.code = 0,
|
||||
.code_data_segment = 1,
|
||||
.DPL = 0,
|
||||
.present = 1,
|
||||
.limit_high = 0xF,
|
||||
.available = 0,
|
||||
.long_mode = 0,
|
||||
.big = 1,
|
||||
.gran = 1,
|
||||
.base_high = 0x00
|
||||
}
|
||||
}};
|
||||
|
||||
void gdt_initialize()
|
||||
{
|
||||
auto gdtr = reinterpret_cast<std::uint64_t>(gdt.data());
|
||||
gdtr <<= 16;
|
||||
gdtr |= gdt.size() * sizeof(gdt[0]);
|
||||
|
||||
asm volatile(R"(
|
||||
lgdt %0
|
||||
pushl $0x8
|
||||
push $.setcs
|
||||
ljmp *(%%esp)
|
||||
.setcs:
|
||||
add $8, %%esp
|
||||
mov $0x10, %%eax
|
||||
mov %%eax, %%ds
|
||||
mov %%eax, %%es
|
||||
mov %%eax, %%fs
|
||||
mov %%eax, %%gs
|
||||
mov %%eax, %%ss
|
||||
)" :: "m"(gdtr));
|
||||
}
|
||||
|
||||
@ -0,0 +1,7 @@
|
||||
#ifndef GDT_HPP
|
||||
#define GDT_HPP
|
||||
|
||||
void gdt_initialize();
|
||||
|
||||
#endif // GDT_HPP
|
||||
|
||||
@ -0,0 +1,107 @@
|
||||
#include "idt.hpp"
|
||||
#include "portio.hpp"
|
||||
#include "textoutput.hpp"
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include <utility>
|
||||
|
||||
extern TextOutput& term;
|
||||
|
||||
static constexpr std::uint8_t TaskGate = 0x5;
|
||||
static constexpr std::uint8_t IntrGate16 = 0x6;
|
||||
static constexpr std::uint8_t TrapGate16 = 0x7;
|
||||
static constexpr std::uint8_t IntrGate32 = 0xE;
|
||||
static constexpr std::uint8_t TrapGate32 = 0xF;
|
||||
|
||||
struct idt_entry_bits {
|
||||
std::uint32_t offset_low : 16;
|
||||
std::uint32_t segment_selector : 16;
|
||||
std::uint32_t rsvd : 8;
|
||||
std::uint32_t gate_type : 4;
|
||||
std::uint32_t rsvd2 : 1;
|
||||
std::uint32_t dpl : 2;
|
||||
std::uint32_t present : 1;
|
||||
std::uint32_t offset_high : 16;
|
||||
} __attribute__((packed));
|
||||
|
||||
static std::array<Callback, 48> callbacks;
|
||||
|
||||
extern "C"
|
||||
void interruptGeneralHandler(Registers regs)
|
||||
{
|
||||
const auto& inum = regs.inum;
|
||||
|
||||
if (inum >= 32) {
|
||||
if (inum >= 40)
|
||||
outb(0xA0, 0x20);
|
||||
|
||||
outb(0x20, 0x20);
|
||||
}
|
||||
|
||||
if (inum < callbacks.size()) {
|
||||
if (auto cb = callbacks[inum]; cb)
|
||||
cb(regs);
|
||||
}
|
||||
}
|
||||
|
||||
template<std::size_t N>
|
||||
struct StubEntry
|
||||
{
|
||||
static constexpr bool HasError = N == 8 || (N >= 10 && N <= 14) || N == 17 || N == 30;
|
||||
|
||||
__attribute__((naked))
|
||||
static void stub() {
|
||||
if constexpr (!HasError)
|
||||
asm volatile("push $0x0");
|
||||
|
||||
asm volatile(R"(
|
||||
pusha
|
||||
push %0
|
||||
cld
|
||||
call interruptGeneralHandler
|
||||
pop %%eax
|
||||
popa
|
||||
add $0x4, %%esp
|
||||
iret
|
||||
)" :: "i"(N));
|
||||
}
|
||||
|
||||
static constexpr std::uint32_t segment(std::uint16_t gdt_idx, bool useLdt, std::uint16_t rpl) {
|
||||
return gdt_idx | (useLdt ? 0x4 : 0x0) | (rpl & 0x3);
|
||||
}
|
||||
|
||||
idt_entry_bits entry = {
|
||||
.offset_low = (uint32_t)stub & 0xFFFF,
|
||||
.segment_selector = segment(0x8, false, 0),
|
||||
.gate_type = IntrGate32,
|
||||
.dpl = 0,
|
||||
.present = 1,
|
||||
.offset_high = (uint32_t)stub >> 16
|
||||
};
|
||||
|
||||
operator idt_entry_bits() const noexcept {
|
||||
return entry;
|
||||
}
|
||||
};
|
||||
|
||||
static auto idt =
|
||||
[]<std::size_t... ints>(std::index_sequence<ints...>) {
|
||||
return std::array<idt_entry_bits, 256> { StubEntry<ints>()... };
|
||||
}(std::make_index_sequence<48>{});
|
||||
|
||||
void idt_initialize()
|
||||
{
|
||||
auto idtr = reinterpret_cast<std::uint64_t>(idt.data());
|
||||
idtr <<= 16;
|
||||
idtr |= idt.size() * sizeof(idt[0]);
|
||||
|
||||
asm volatile("lidt %0" :: "m"(idtr));
|
||||
}
|
||||
|
||||
void idt_register_callback(std::size_t num, Callback cb)
|
||||
{
|
||||
if (num < callbacks.size())
|
||||
callbacks[num] = cb;
|
||||
}
|
||||
|
||||
@ -0,0 +1,21 @@
|
||||
#ifndef IDT_HPP
|
||||
#define IDT_HPP
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
|
||||
struct Registers
|
||||
{
|
||||
std::uint32_t inum;
|
||||
std::uint32_t edi, esi, ebp, esp, ebx, edx, ecx, eax;
|
||||
std::uint32_t error;
|
||||
std::uint32_t eip, cs, eflags;
|
||||
} __attribute__((packed));
|
||||
|
||||
using Callback = void (*)(const Registers&);
|
||||
|
||||
void idt_initialize();
|
||||
void idt_register_callback(std::size_t num, Callback cb);
|
||||
|
||||
#endif // IDT_HPP
|
||||
|
||||
@ -0,0 +1,4 @@
|
||||
menuentry "myos" {
|
||||
multiboot2 /boot/myos.bin
|
||||
}
|
||||
|
||||
@ -0,0 +1,55 @@
|
||||
#include "gdt.hpp"
|
||||
#include "idt.hpp"
|
||||
#include "memory.hpp"
|
||||
#include "multiboot.hpp"
|
||||
#include "pic.hpp"
|
||||
#include "pit.hpp"
|
||||
#include "tasking.hpp"
|
||||
#include "vgaterminal.hpp"
|
||||
|
||||
static VGATerminal vga;
|
||||
TextOutput& term = vga;
|
||||
|
||||
extern "C"
|
||||
void kernel_main(void)
|
||||
{
|
||||
term.write("Clyne's kernel, v2024\n\n");
|
||||
|
||||
if (!multiboot_initialize())
|
||||
for (;;);
|
||||
|
||||
idt_register_callback(14, [](const Registers& regs) {
|
||||
term.write("Page fault! eip=");
|
||||
term.write(regs.eip);
|
||||
term.write('\n');
|
||||
for (;;);
|
||||
});
|
||||
|
||||
memory_initialize();
|
||||
gdt_initialize();
|
||||
pic_initialize();
|
||||
idt_initialize();
|
||||
pit_initialize(50);
|
||||
asm volatile("sti");
|
||||
tasking_initialize();
|
||||
term.write("Tasking enabled.\n");
|
||||
|
||||
tasking_spawn([] {
|
||||
for (;;)
|
||||
term.write('B');
|
||||
}, 256);
|
||||
|
||||
for (;;)
|
||||
term.write('A');
|
||||
}
|
||||
|
||||
extern "C"
|
||||
void memmove(char* dst, char* src, size_t sz) {
|
||||
while (sz) {
|
||||
*dst = *src;
|
||||
++dst;
|
||||
++src;
|
||||
--sz;
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,66 @@
|
||||
/* The bootloader will look at this image and start execution at the symbol
|
||||
designated as the entry point. */
|
||||
ENTRY(_start)
|
||||
|
||||
/* Tell where the various sections of the object files will be put in the final
|
||||
kernel image. */
|
||||
SECTIONS
|
||||
{
|
||||
/* It used to be universally recommended to use 1M as a start offset,
|
||||
as it was effectively guaranteed to be available under BIOS systems.
|
||||
However, UEFI has made things more complicated, and experimental data
|
||||
strongly suggests that 2M is a safer place to load. In 2016, a new
|
||||
feature was introduced to the multiboot2 spec to inform bootloaders
|
||||
that a kernel can be loaded anywhere within a range of addresses and
|
||||
will be able to relocate itself to run from such a loader-selected
|
||||
address, in order to give the loader freedom in selecting a span of
|
||||
memory which is verified to be available by the firmware, in order to
|
||||
work around this issue. This does not use that feature, so 2M was
|
||||
chosen as a safer option than the traditional 1M. */
|
||||
. = 2M;
|
||||
|
||||
/* First put the multiboot header, as it is required to be put very early
|
||||
in the image or the bootloader won't recognize the file format.
|
||||
Next we'll put the .text section. */
|
||||
.text BLOCK(4K) : ALIGN(4K)
|
||||
{
|
||||
*(.multiboot2)
|
||||
*(.text)
|
||||
}
|
||||
|
||||
/* Read-only data. */
|
||||
.rodata BLOCK(4K) : ALIGN(4K)
|
||||
{
|
||||
*(.rodata)
|
||||
}
|
||||
|
||||
.init_array :
|
||||
{
|
||||
__init_array_start = .;
|
||||
*(.init_array)
|
||||
__init_array_end = .;
|
||||
}
|
||||
|
||||
/* Read-write data (initialized) */
|
||||
.data BLOCK(4K) : ALIGN(4K)
|
||||
{
|
||||
*(.data)
|
||||
}
|
||||
|
||||
/* Read-write data (uninitialized) and stack */
|
||||
.bss BLOCK(4K) : ALIGN(4K)
|
||||
{
|
||||
*(COMMON)
|
||||
*(.bss)
|
||||
}
|
||||
|
||||
/* The compiler may produce other sections, by default it will put them in
|
||||
a segment with the same name. Simply add stuff here as needed. */
|
||||
|
||||
.note :
|
||||
{
|
||||
*(.note)
|
||||
*(.note*)
|
||||
}
|
||||
}
|
||||
|
||||
@ -0,0 +1,87 @@
|
||||
#include "textoutput.hpp"
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
|
||||
struct PageDirectory
|
||||
{
|
||||
static constexpr std::uint32_t NotPresent = 0x2;
|
||||
|
||||
PageDirectory(): value(NotPresent) {}
|
||||
PageDirectory(void *addr): value(reinterpret_cast<std::uint32_t>(addr) | 3) {}
|
||||
|
||||
std::uint32_t value;
|
||||
};
|
||||
static_assert(sizeof(PageDirectory) == sizeof(std::uint32_t));
|
||||
|
||||
extern std::uint32_t lowerMem;
|
||||
extern std::uint32_t upperMem;
|
||||
extern TextOutput& term;
|
||||
|
||||
static std::uintptr_t lowerFree = 0x400;
|
||||
static std::uintptr_t upperFree = 0x100000;
|
||||
|
||||
alignas(4096)
|
||||
static std::array<PageDirectory, 1024> pageDirectory;
|
||||
|
||||
alignas(4096)
|
||||
static std::array<std::uint32_t, 1024> pageTable;
|
||||
|
||||
void memory_initialize()
|
||||
{
|
||||
lowerMem -= 1024;
|
||||
|
||||
const auto totalKb = (lowerMem + upperMem) / 1024u;
|
||||
|
||||
term.write("Claiming ");
|
||||
term.write(totalKb);
|
||||
term.write(" kB for allocations...\n");
|
||||
|
||||
std::uint32_t addr = 0;
|
||||
for (auto& p : pageTable) {
|
||||
p = addr | 3; // supervisor, r/w, present
|
||||
addr += 0x1000;
|
||||
}
|
||||
|
||||
pageDirectory[0] = PageDirectory(pageTable.data());
|
||||
|
||||
asm volatile(R"(
|
||||
mov %%eax, %%cr3
|
||||
mov %%cr0, %%eax
|
||||
or $0x80000000, %%eax
|
||||
mov %%eax, %%cr0
|
||||
)" :: "a"(pageDirectory.data()));
|
||||
|
||||
term.write("Paging enabled.\n");
|
||||
}
|
||||
|
||||
static void *memory_alloc(std::size_t size)
|
||||
{
|
||||
void *ret = nullptr;
|
||||
|
||||
if (lowerMem > size) {
|
||||
ret = reinterpret_cast<void *>(lowerFree);
|
||||
lowerFree += size;
|
||||
lowerMem -= size;
|
||||
} else if (upperMem > size) {
|
||||
ret = reinterpret_cast<void *>(upperFree);
|
||||
upperFree += size;
|
||||
upperMem -= size;
|
||||
} else {
|
||||
// Uh oh!
|
||||
term.write("!!! Kernel allocation failed !!!");
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void *operator new(std::size_t size)
|
||||
{
|
||||
return memory_alloc(size);
|
||||
}
|
||||
|
||||
void *operator new[](std::size_t size)
|
||||
{
|
||||
return memory_alloc(size);
|
||||
}
|
||||
|
||||
@ -0,0 +1,7 @@
|
||||
#ifndef MEMORY_HPP
|
||||
#define MEMORY_HPP
|
||||
|
||||
void memory_initialize();
|
||||
|
||||
#endif // MEMORY_HPP
|
||||
|
||||
@ -0,0 +1,41 @@
|
||||
#include "textoutput.hpp"
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
extern TextOutput& term;
|
||||
|
||||
std::uint32_t multiboot_magic;
|
||||
std::uint32_t *multiboot_ptr;
|
||||
|
||||
std::uint32_t lowerMem = 0;
|
||||
std::uint32_t upperMem = 0;
|
||||
|
||||
bool multiboot_initialize()
|
||||
{
|
||||
if (multiboot_magic != 0x36d76289) {
|
||||
term.write("Not multiboot!");
|
||||
return false;
|
||||
}
|
||||
|
||||
term.write("Found multiboot headers: ");
|
||||
|
||||
auto ptr = multiboot_ptr + 2;
|
||||
while (ptr[0] != 0 && ptr[1] != 8) {
|
||||
term.write(ptr[0]);
|
||||
term.write(", ");
|
||||
|
||||
if (ptr[0] == 4) {
|
||||
lowerMem = ptr[2] * 1024;
|
||||
upperMem = ptr[3] * 1024;
|
||||
}
|
||||
|
||||
auto next = reinterpret_cast<std::uintptr_t>(ptr);
|
||||
next += ptr[1];
|
||||
next = (next + 7) & ~7;
|
||||
ptr = reinterpret_cast<std::uint32_t *>(next);
|
||||
}
|
||||
|
||||
term.write('\n');
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -0,0 +1,7 @@
|
||||
#ifndef MULTIBOOT_HPP
|
||||
#define MULTIBOOT_HPP
|
||||
|
||||
bool multiboot_initialize();
|
||||
|
||||
#endif // MULTIBOOT_HPP
|
||||
|
||||
@ -0,0 +1,63 @@
|
||||
#include "pic.hpp"
|
||||
|
||||
#include "portio.hpp"
|
||||
|
||||
#define PIC1 0x20 /* IO base address for master PIC */
|
||||
#define PIC2 0xA0 /* IO base address for slave PIC */
|
||||
#define PIC1_COMMAND PIC1
|
||||
#define PIC1_DATA (PIC1+1)
|
||||
#define PIC2_COMMAND PIC2
|
||||
#define PIC2_DATA (PIC2+1)
|
||||
|
||||
#define PIC_EOI 0x20 /* End-of-interrupt command code */
|
||||
|
||||
#define ICW1_ICW4 0x01 /* Indicates that ICW4 will be present */
|
||||
#define ICW1_SINGLE 0x02 /* Single (cascade) mode */
|
||||
#define ICW1_INTERVAL4 0x04 /* Call address interval 4 (8) */
|
||||
#define ICW1_LEVEL 0x08 /* Level triggered (edge) mode */
|
||||
#define ICW1_INIT 0x10 /* Initialization - required! */
|
||||
|
||||
#define ICW4_8086 0x01 /* 8086/88 (MCS-80/85) mode */
|
||||
#define ICW4_AUTO 0x02 /* Auto (normal) EOI */
|
||||
#define ICW4_BUF_SLAVE 0x08 /* Buffered mode/slave */
|
||||
#define ICW4_BUF_MASTER 0x0C /* Buffered mode/master */
|
||||
#define ICW4_SFNM 0x10 /* Special fully nested (not) */
|
||||
|
||||
void pic_initialize()
|
||||
{
|
||||
constexpr int offset1 = 0x20, offset2 = 0x28;
|
||||
std::uint8_t a1, a2;
|
||||
|
||||
a1 = inb(PIC1_DATA); // save masks
|
||||
a2 = inb(PIC2_DATA);
|
||||
|
||||
outb(PIC1_COMMAND, ICW1_INIT | ICW1_ICW4); // starts the initialization sequence (in cascade mode)
|
||||
io_wait();
|
||||
outb(PIC2_COMMAND, ICW1_INIT | ICW1_ICW4);
|
||||
io_wait();
|
||||
outb(PIC1_DATA, offset1); // ICW2: Master PIC vector offset
|
||||
io_wait();
|
||||
outb(PIC2_DATA, offset2); // ICW2: Slave PIC vector offset
|
||||
io_wait();
|
||||
outb(PIC1_DATA, 4); // ICW3: tell Master PIC that there is a slave PIC at IRQ2 (0000 0100)
|
||||
io_wait();
|
||||
outb(PIC2_DATA, 2); // ICW3: tell Slave PIC its cascade identity (0000 0010)
|
||||
io_wait();
|
||||
|
||||
outb(PIC1_DATA, ICW4_8086); // ICW4: have the PICs use 8086 mode (and not 8080 mode)
|
||||
io_wait();
|
||||
outb(PIC2_DATA, ICW4_8086);
|
||||
io_wait();
|
||||
|
||||
outb(PIC1_DATA, a1); // restore saved masks.
|
||||
outb(PIC2_DATA, a2);
|
||||
}
|
||||
|
||||
void pic_eoi(std::uint8_t irq)
|
||||
{
|
||||
if (irq >= 8)
|
||||
outb(PIC2_COMMAND, PIC_EOI);
|
||||
|
||||
outb(PIC1_COMMAND, PIC_EOI);
|
||||
}
|
||||
|
||||
@ -0,0 +1,12 @@
|
||||
#ifndef PIC_HPP
|
||||
#define PIC_HPP
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
/* reinitialize the PIC controllers, giving them specified vector offsets
|
||||
rather than 8h and 70h, as configured by default */
|
||||
void pic_initialize();
|
||||
void pic_eoi(std::uint8_t irq);
|
||||
|
||||
#endif // PIC_HPP
|
||||
|
||||
@ -0,0 +1,39 @@
|
||||
#include "pit.hpp"
|
||||
#include "idt.hpp"
|
||||
#include "portio.hpp"
|
||||
#include "tasking.hpp"
|
||||
|
||||
static volatile std::uint32_t ticks = 0;
|
||||
|
||||
static void timer_callback(const Registers& regs)
|
||||
{
|
||||
ticks = ticks + 1;
|
||||
|
||||
schedule(const_cast<Registers&>(regs));
|
||||
}
|
||||
|
||||
void pit_initialize(std::uint32_t frequency)
|
||||
{
|
||||
// Firstly, register our timer callback.
|
||||
idt_register_callback(32, timer_callback);
|
||||
|
||||
// The value we send to the PIT is the value to divide it's input clock
|
||||
// (1193180 Hz) by, to get our required frequency. Important to note is
|
||||
// that the divisor must be small enough to fit into 16-bits.
|
||||
auto divisor = 1193180 / frequency;
|
||||
|
||||
// Send the command byte.
|
||||
outb(0x43, 0x36);
|
||||
|
||||
// Send the frequency divisor.
|
||||
outb(0x40, divisor & 0xFF);
|
||||
outb(0x40, (divisor >> 8) & 0xFF);
|
||||
}
|
||||
|
||||
void pit_busy_wait(std::int32_t tks)
|
||||
{
|
||||
const auto end = ticks + tks;
|
||||
while (end - ticks > 0)
|
||||
asm volatile("nop");
|
||||
}
|
||||
|
||||
@ -0,0 +1,10 @@
|
||||
#ifndef PIT_HPP
|
||||
#define PIT_HPP
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
void pit_initialize(std::uint32_t frequency);
|
||||
void pit_busy_wait(std::int32_t tks);
|
||||
|
||||
#endif // PIT_HPP
|
||||
|
||||
@ -0,0 +1,24 @@
|
||||
#ifndef PORTIO_HPP
|
||||
#define PORTIO_HPP
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
inline void outb(std::uint16_t port, std::uint8_t val)
|
||||
{
|
||||
asm volatile("outb %b0, %w1" :: "a"(val), "Nd"(port) : "memory");
|
||||
}
|
||||
|
||||
inline std::uint8_t inb(std::uint16_t port)
|
||||
{
|
||||
std::uint8_t val;
|
||||
asm volatile("inb %w1, %b0" : "=a"(val) : "Nd"(port) : "memory");
|
||||
return val;
|
||||
}
|
||||
|
||||
inline void io_wait()
|
||||
{
|
||||
outb(0x80, 0);
|
||||
}
|
||||
|
||||
#endif // PORTIO_HPP
|
||||
|
||||
@ -0,0 +1,60 @@
|
||||
#include "tasking.hpp"
|
||||
|
||||
#include <array>
|
||||
|
||||
struct Task
|
||||
{
|
||||
Registers regs;
|
||||
bool valid = false;
|
||||
};
|
||||
|
||||
static std::array<Task, 4> tasks;
|
||||
static int current = -1;
|
||||
|
||||
void schedule(Registers& regs)
|
||||
{
|
||||
if (current < 0)
|
||||
return;
|
||||
|
||||
tasks[current].regs = regs;
|
||||
|
||||
do {
|
||||
if (++current >= tasks.size())
|
||||
current = 0;
|
||||
} while (!tasks[current].valid);
|
||||
|
||||
regs = tasks[current].regs;
|
||||
}
|
||||
|
||||
void tasking_initialize()
|
||||
{
|
||||
tasks[0].valid = true;
|
||||
current = 0;
|
||||
asm volatile("int $0x20");
|
||||
}
|
||||
|
||||
bool tasking_spawn(void (*entry)(), unsigned ssize)
|
||||
{
|
||||
int i = -1;
|
||||
for (i = 0; i < tasks.size(); ++i) {
|
||||
if (!tasks[i].valid)
|
||||
break;
|
||||
}
|
||||
|
||||
if (i < 0)
|
||||
return false;
|
||||
|
||||
tasks[i] = Task();
|
||||
|
||||
auto& r = tasks[i].regs;
|
||||
auto stack = reinterpret_cast<std::uint32_t>(new std::uint8_t[ssize]);
|
||||
r.ebp = stack + ssize;
|
||||
r.esp = r.ebp;
|
||||
r.eip = reinterpret_cast<std::uint32_t>(entry);
|
||||
r.cs = 0x8;
|
||||
r.eflags = tasks[current].regs.eflags;
|
||||
|
||||
tasks[i].valid = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -0,0 +1,12 @@
|
||||
#ifndef TASKING_HPP
|
||||
#define TASKING_HPP
|
||||
|
||||
#include "idt.hpp"
|
||||
|
||||
void tasking_initialize();
|
||||
bool tasking_spawn(void (*entry)(), unsigned ssize);
|
||||
|
||||
void schedule(Registers& regs);
|
||||
|
||||
#endif // TASKING_HPP
|
||||
|
||||
@ -0,0 +1,44 @@
|
||||
#ifndef TEXTOUTPUT_HPP
|
||||
#define TEXTOUTPUT_HPP
|
||||
|
||||
class TextOutput
|
||||
{
|
||||
public:
|
||||
virtual void write(char c) noexcept = 0;
|
||||
|
||||
void write(const char *s) noexcept {
|
||||
if (s) {
|
||||
while (*s)
|
||||
write(*s++);
|
||||
}
|
||||
}
|
||||
|
||||
void write(int n) noexcept {
|
||||
char buf[32];
|
||||
auto ptr = buf + sizeof(buf);
|
||||
|
||||
*--ptr = '\0';
|
||||
do {
|
||||
*--ptr = "0123456789"[n % 10];
|
||||
n /= 10;
|
||||
} while (n);
|
||||
|
||||
write(ptr);
|
||||
}
|
||||
|
||||
void write(unsigned n) noexcept {
|
||||
char buf[32];
|
||||
auto ptr = buf + sizeof(buf);
|
||||
|
||||
*--ptr = '\0';
|
||||
do {
|
||||
*--ptr = "0123456789"[n % 10];
|
||||
n /= 10;
|
||||
} while (n);
|
||||
|
||||
write(ptr);
|
||||
}
|
||||
};
|
||||
|
||||
#endif // TEXTOUTPUT_HPP
|
||||
|
||||
@ -0,0 +1,54 @@
|
||||
#include "portio.hpp"
|
||||
#include "vgaterminal.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <utility>
|
||||
|
||||
void VGATerminal::write(char c) noexcept
|
||||
{
|
||||
switch (c) {
|
||||
case '\n':
|
||||
offset += Width;
|
||||
[[fallthrough]];
|
||||
case '\r':
|
||||
offset -= offset % Width;
|
||||
break;
|
||||
default:
|
||||
checkpos();
|
||||
put(c);
|
||||
updatecursor();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void VGATerminal::put(char c) noexcept
|
||||
{
|
||||
std::uint16_t cell = c
|
||||
| (std::to_underlying(foreground) << 8)
|
||||
| (std::to_underlying(background) << 12);
|
||||
|
||||
auto ptr = reinterpret_cast<std::uint16_t *>(Videoram);
|
||||
ptr[offset++] = cell;
|
||||
}
|
||||
|
||||
void VGATerminal::checkpos() noexcept
|
||||
{
|
||||
if (offset >= Width * Height) {
|
||||
auto ptr = reinterpret_cast<std::uint16_t *>(Videoram);
|
||||
const auto end = ptr + Width * Height;
|
||||
std::copy(ptr + Width, end, ptr);
|
||||
std::fill(end - Width, end, 0);
|
||||
offset = Width * Height - Width;
|
||||
}
|
||||
}
|
||||
|
||||
void VGATerminal::updatecursor() const noexcept
|
||||
{
|
||||
outb(0x03d4, 0x0f);
|
||||
outb(0x03d5, static_cast<std::uint8_t>(offset));
|
||||
outb(0x03d4, 0x0e);
|
||||
outb(0x03d5, static_cast<std::uint8_t>(offset >> 8));
|
||||
}
|
||||
|
||||
@ -0,0 +1,51 @@
|
||||
#ifndef VGATERMINAL_HPP
|
||||
#define VGATERMINAL_HPP
|
||||
|
||||
#include "textoutput.hpp"
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
|
||||
class VGATerminal : public TextOutput
|
||||
{
|
||||
public:
|
||||
enum class Color : std::uint8_t
|
||||
{
|
||||
Black = 0,
|
||||
Blue,
|
||||
Green,
|
||||
Cyan,
|
||||
Red,
|
||||
Magenta,
|
||||
Brown,
|
||||
LightGray,
|
||||
DarkGray,
|
||||
LightBlue,
|
||||
LightGreen,
|
||||
LightCyan,
|
||||
LightRed,
|
||||
LightMagenta,
|
||||
LightBrown,
|
||||
White
|
||||
};
|
||||
|
||||
using enum Color;
|
||||
|
||||
virtual void write(char c) noexcept final;
|
||||
|
||||
private:
|
||||
static constexpr std::uintptr_t Videoram = 0xB8000;
|
||||
static constexpr unsigned Width = 80;
|
||||
static constexpr unsigned Height = 25;
|
||||
|
||||
unsigned offset = 0;
|
||||
Color foreground = LightGray;
|
||||
Color background = Black;
|
||||
|
||||
void put(char c) noexcept;
|
||||
void checkpos() noexcept;
|
||||
void updatecursor() const noexcept;
|
||||
};
|
||||
|
||||
#endif // VGATERMINAL_HPP
|
||||
|
||||
Loading…
Reference in New Issue