Sinipelto/banan-os
1
0
Fork 0
forked from Bananymous/banan-os
Code Pull Requests Activity

All: rename every function from UpperCamelCase to snake_case

Browse Source 
This was a mess since I didn't know which to use but now I decided
to go with snake_case :)
This commit is contained in:
Bananymous
2023-02-01 21:05:44 +02:00
parent 4faa662a59
commit 9b8de5025a
50 changed files with 737 additions and 709 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
kernel/arch/i386/IDT.cpp
View File

@@ -17,7 +17,7 @@
asm volatile("movl %%cr2, %%eax":"=a"(cr2)); \
asm volatile("movl %%cr3, %%eax":"=a"(cr3)); \
asm volatile("movl %%cr4, %%eax":"=a"(cr4)); \
Kernel::Panic(msg "\r\nRegister dump\r\n" \
Kernel::panic(msg "\r\nRegister dump\r\n" \
"eax=0x{8H}, ebx=0x{8H}, ecx=0x{8H}, edx=0x{8H}\r\n" \
"esp=0x{8H}, ebp=0x{8H}\r\n" \
"CR0=0x{8H}, CR2=0x{8H}, CR3=0x{8H}, CR4=0x{8H}\r\n", \
@@ -39,7 +39,7 @@
asm volatile("movl %%cr3, %%eax":"=a"(cr3)); \
asm volatile("movl %%cr4, %%eax":"=a"(cr4)); \
asm volatile("popl %%eax":"=a"(error_code)); \
Kernel::Panic(msg " (error code: 0x{8H})\r\n" \
Kernel::panic(msg " (error code: 0x{8H})\r\n" \
"Register dump\r\n" \
"eax=0x{8H}, ebx=0x{8H}, ecx=0x{8H}, edx=0x{8H}\r\n" \
"esp=0x{8H}, ebp=0x{8H}\r\n" \
@@ -114,7 +114,7 @@ namespace IDT
uint8_t irq = 0;
for (uint32_t i = 0; i <= 0xFF; i++)
{
if (InterruptController::Get().IsInService(i))
if (InterruptController::get().is_in_service(i))
{
irq = i;
break;
@@ -132,7 +132,7 @@ namespace IDT
else
dprintln("no handler for irq 0x{2H}\n", irq);
InterruptController::Get().EOI(irq);
InterruptController::get().eoi(irq);
}
extern "C" void handle_irq_common();

16
kernel/arch/i386/MMU.cpp
View File

@@ -16,13 +16,13 @@
static MMU* s_instance = nullptr;
void MMU::Intialize()
void MMU::intialize()
{
ASSERT(s_instance == nullptr);
s_instance = new MMU();
}
MMU& MMU::Get()
MMU& MMU::get()
{
ASSERT(s_instance);
return *s_instance;
@@ -70,7 +70,7 @@ MMU::MMU()
asm volatile("movl %0, %%cr3" :: "r"(m_highest_paging_struct));
}
void MMU::AllocatePage(uintptr_t address)
void MMU::allocate_page(uintptr_t address)
{
#if MMU_DEBUG_PRINT
dprintln("AllocatePage(0x{8H})", address & PAGE_MASK);
@@ -93,15 +93,15 @@ void MMU::AllocatePage(uintptr_t address)
asm volatile("invlpg (%0)" :: "r"(address & PAGE_MASK) : "memory");
}
void MMU::AllocateRange(uintptr_t address, ptrdiff_t size)
void MMU::allocate_range(uintptr_t address, ptrdiff_t size)
{
uintptr_t s_page = address & PAGE_MASK;
uintptr_t e_page = (address + size - 1) & PAGE_MASK;
for (uintptr_t page = s_page; page <= e_page; page += PAGE_SIZE)
AllocatePage(page);
allocate_page(page);
}
void MMU::UnAllocatePage(uintptr_t address)
void MMU::unallocate_page(uintptr_t address)
{
#if MMU_DEBUG_PRINT
dprintln("UnAllocatePage(0x{8H})", address & PAGE_MASK);
@@ -126,10 +126,10 @@ void MMU::UnAllocatePage(uintptr_t address)
asm volatile("invlpg (%0)" :: "r"(address & PAGE_MASK) : "memory");
}
void MMU::UnAllocateRange(uintptr_t address, ptrdiff_t size)
void MMU::unallocate_range(uintptr_t address, ptrdiff_t size)
{
uintptr_t s_page = address & PAGE_MASK;
uintptr_t e_page = (address + size - 1) & PAGE_MASK;
for (uintptr_t page = s_page; page <= e_page; page += PAGE_SIZE)
UnAllocatePage(page);
unallocate_page(page);
}

6
kernel/arch/x86_64/IDT.cpp
View File

@@ -97,7 +97,7 @@ namespace IDT
extern "C" void cpp_isr_handler(uint64_t isr, uint64_t error, const Registers* regs)
{
Kernel::Panic(
Kernel::panic(
"{} (error code: 0x{16H})\r\n"
"Register dump\r\n"
"rax=0x{16H}, rbx=0x{16H}, rcx=0x{16H}, rdx=0x{16H}\r\n"
@@ -118,7 +118,7 @@ namespace IDT
s_irq_handlers[irq]();
else
{
if (!InterruptController::Get().IsInService(irq))
if (!InterruptController::get().is_in_service(irq))
{
dprintln("spurious irq 0x{2H}", irq);
return;
@@ -126,7 +126,7 @@ namespace IDT
dprintln("no handler for irq 0x{2H}\n", irq);
}
InterruptController::Get().EOI(irq);
InterruptController::get().eoi(irq);
}
static void flush_idt()

16
kernel/arch/x86_64/MMU.cpp
View File

@@ -16,13 +16,13 @@
static MMU* s_instance = nullptr;
void MMU::Intialize()
void MMU::intialize()
{
ASSERT(s_instance == nullptr);
s_instance = new MMU();
}
MMU& MMU::Get()
MMU& MMU::get()
{
ASSERT(s_instance);
return *s_instance;
@@ -89,7 +89,7 @@ MMU::~MMU()
kfree(pml4);
}
void MMU::AllocatePage(uintptr_t address)
void MMU::allocate_page(uintptr_t address)
{
ASSERT((address >> 48) == 0);
@@ -129,15 +129,15 @@ void MMU::AllocatePage(uintptr_t address)
}
}
void MMU::AllocateRange(uintptr_t address, ptrdiff_t size)
void MMU::allocate_range(uintptr_t address, ptrdiff_t size)
{
uintptr_t s_page = address & PAGE_MASK;
uintptr_t e_page = (address + size - 1) & PAGE_MASK;
for (uintptr_t page = s_page; page <= e_page; page += PAGE_SIZE)
AllocatePage(page);
allocate_page(page);
}
void MMU::UnAllocatePage(uintptr_t address)
void MMU::unallocate_page(uintptr_t address)
{
ASSERT((address >> 48) == 0);
@@ -177,10 +177,10 @@ cleanup_done:
asm volatile("invlpg (%0)" :: "r"(address) : "memory");
}
void MMU::UnAllocateRange(uintptr_t address, ptrdiff_t size)
void MMU::unallocate_range(uintptr_t address, ptrdiff_t size)
{
uintptr_t s_page = address & PAGE_MASK;
uintptr_t e_page = (address + size - 1) & PAGE_MASK;
for (uintptr_t page = s_page; page <= e_page; page += PAGE_SIZE)
UnAllocatePage(page);
unallocate_page(page);
}

16
kernel/include/kernel/APIC.h
View File

@@ -6,16 +6,16 @@
class APIC final : public InterruptController
{
public:
virtual void EOI(uint8_t) override;
virtual void EnableIrq(uint8_t) override;
virtual bool IsInService(uint8_t) override;
virtual void eoi(uint8_t) override;
virtual void enable_irq(uint8_t) override;
virtual bool is_in_service(uint8_t) override;
private:
uint32_t ReadFromLocalAPIC(ptrdiff_t);
void WriteToLocalAPIC(ptrdiff_t, uint32_t);
uint32_t read_from_local_apic(ptrdiff_t);
void write_to_local_apic(ptrdiff_t, uint32_t);
private:
static APIC* Create();
static APIC* create();
friend class InterruptController;
private:
@@ -38,8 +38,8 @@ private:
uint32_t gsi_base;
uint8_t max_redirs;
uint32_t Read(uint8_t offset);
void Write(uint8_t offset, uint32_t data);
uint32_t read(uint8_t offset);
void write(uint8_t offset, uint32_t data);
};
private:

10
kernel/include/kernel/CPUID.h
View File

@@ -71,11 +71,11 @@ namespace CPUID
EDX_PBE = (uint32_t)1 << 31,
};
const char* FeatStringECX(uint32_t feat);
const char* FeatStringEDX(uint32_t feat);
const char* feature_string_ecx(uint32_t feat);
const char* feature_string_edx(uint32_t feat);
const char* GetVendor();
void GetFeatures(uint32_t& ecx, uint32_t& edx);
bool Is64Bit();
const char* get_vendor();
void get_features(uint32_t& ecx, uint32_t& edx);
bool is_64_bit();
}

2
kernel/include/kernel/Debug.h
View File

@@ -28,6 +28,6 @@
namespace Debug
{
void DumpStackTrace();
void dump_stack_trace();
void putchar(char);
}

10
kernel/include/kernel/InterruptController.h
View File

@@ -7,10 +7,10 @@ class InterruptController
public:
virtual ~InterruptController() {}
virtual void EOI(uint8_t) = 0;
virtual void EnableIrq(uint8_t) = 0;
virtual bool IsInService(uint8_t) = 0;
virtual void eoi(uint8_t) = 0;
virtual void enable_irq(uint8_t) = 0;
virtual bool is_in_service(uint8_t) = 0;
static void Initialize(bool force_pic);
static InterruptController& Get();
static void initialize(bool force_pic);
static InterruptController& get();
};

12
kernel/include/kernel/MMU.h
View File

@@ -6,17 +6,17 @@
class MMU
{
public:
static void Intialize();
static MMU& Get();
static void intialize();
static MMU& get();
MMU();
~MMU();
void AllocatePage(uintptr_t);
void AllocateRange(uintptr_t, ptrdiff_t);
void allocate_page(uintptr_t);
void allocate_range(uintptr_t, ptrdiff_t);
void UnAllocatePage(uintptr_t);
void UnAllocateRange(uintptr_t, ptrdiff_t);
void unallocate_page(uintptr_t);
void unallocate_range(uintptr_t, ptrdiff_t);
private:
uint64_t* m_highest_paging_struct;

12
kernel/include/kernel/PIC.h
View File

@@ -5,14 +5,14 @@
class PIC final : public InterruptController
{
public:
virtual void EOI(uint8_t) override;
virtual void EnableIrq(uint8_t) override;
virtual bool IsInService(uint8_t) override;
virtual void eoi(uint8_t) override;
virtual void enable_irq(uint8_t) override;
virtual bool is_in_service(uint8_t) override;
static void Remap();
static void MaskAll();
static void remap();
static void mask_all();
private:
static PIC* Create();
static PIC* create();
friend class InterruptController;
};

25
kernel/include/kernel/Panic.h
View File

@@ -3,22 +3,25 @@
#include <kernel/Debug.h>
#include <kernel/kprint.h>
#define Panic(...) PanicImpl(__FILE__, __LINE__, __VA_ARGS__)
#define panic(...) detail::panic_impl(__FILE__, __LINE__, __VA_ARGS__)
namespace Kernel
{
template<typename... Args>
__attribute__((__noreturn__))
static void PanicImpl(const char* file, int line, const char* message, Args... args)
namespace detail
{
derrorln("Kernel panic at {}:{}", file, line);
derrorln(message, args...);
Debug::DumpStackTrace();
asm volatile("cli");
for (;;)
asm volatile("hlt");
__builtin_unreachable();
template<typename... Args>
__attribute__((__noreturn__))
static void panic_impl(const char* file, int line, const char* message, Args... args)
{
derrorln("Kernel panic at {}:{}", file, line);
derrorln(message, args...);
Debug::dump_stack_trace();
asm volatile("cli");
for (;;)
asm volatile("hlt");
__builtin_unreachable();
}
}
}

2
kernel/include/kernel/RTC.h
View File

@@ -5,6 +5,6 @@
namespace RTC
{
BAN::Time GetCurrentTime();
BAN::Time get_current_time();
}

1
kernel/include/kernel/Scheduler.h
View File

@@ -1,5 +1,6 @@
#pragma once
#include <BAN/Function.h>
#include <BAN/LinkedList.h>
#include <kernel/Thread.h>

4
kernel/include/kernel/Serial.h
View File

@@ -3,8 +3,8 @@
namespace Serial
{
void Initialize();
bool IsInitialized();
void initialize();
bool is_initialized();
void putchar(char);

12
kernel/include/kernel/Shell.h
View File

@@ -13,14 +13,14 @@ namespace Kernel
public:
Shell(TTY*);
Shell(const Shell&) = delete;
void SetPrompt(BAN::StringView);
void Run();
void set_prompt(BAN::StringView);
void run();
private:
void ReRenderBuffer() const;
BAN::Vector<BAN::String> ParseArguments(BAN::StringView) const;
void ProcessCommand(const BAN::Vector<BAN::String>&);
void KeyEventCallback(Input::KeyEvent);
void rerender_buffer() const;
BAN::Vector<BAN::String> parse_arguments(BAN::StringView) const;
void process_command(const BAN::Vector<BAN::String>&);
void key_event_callback(Input::KeyEvent);
private:
TTY* m_tty;

28
kernel/include/kernel/TTY.h
View File

@@ -7,26 +7,26 @@ class TTY
{
public:
TTY(TerminalDriver*);
void Clear();
void PutChar(char ch);
void Write(const char* data, size_t size);
void WriteString(const char* data);
void SetCursorPosition(uint32_t x, uint32_t y);
void clear();
void putchar(char ch);
void write(const char* data, size_t size);
void write_string(const char* data);
void set_cursor_position(uint32_t x, uint32_t y);
uint32_t Height() const { return m_height; }
uint32_t Width() const { return m_width; }
uint32_t height() const { return m_height; }
uint32_t width() const { return m_width; }
void RenderFromBuffer(uint32_t x, uint32_t y);
void render_from_buffer(uint32_t x, uint32_t y);
// for kprint
static void PutCharCurrent(char ch);
static bool IsInitialized();
static void putchar_current(char ch);
static bool is_initialized();
private:
void ResetAnsiEscape();
void HandleAnsiSGR();
void HandleAnsiEscape(uint16_t ch);
void PutCharAt(uint16_t ch, uint32_t x, uint32_t y);
void reset_ansi_escape();
void handle_ansi_sgr();
void handle_ansi_escape(uint16_t ch);
void putchar_at(uint16_t ch, uint32_t x, uint32_t y);
private:
struct Cell

10
kernel/include/kernel/TerminalDriver.h
View File

@@ -22,13 +22,13 @@ public:
public:
virtual ~TerminalDriver() {}
virtual uint32_t Width() const = 0;
virtual uint32_t Height() const = 0;
virtual uint32_t width() const = 0;
virtual uint32_t height() const = 0;
virtual void PutCharAt(uint16_t, uint32_t, uint32_t, Color, Color) = 0;
virtual void Clear(Color) = 0;
virtual void putchar_at(uint16_t, uint32_t, uint32_t, Color, Color) = 0;
virtual void clear(Color) = 0;
virtual void SetCursorPosition(uint32_t, uint32_t) = 0;
virtual void set_cursor_position(uint32_t, uint32_t) = 0;
};
namespace TerminalColor

14
kernel/include/kernel/VesaTerminalDriver.h
View File

@@ -6,16 +6,16 @@
class VesaTerminalDriver final : public TerminalDriver
{
public:
static VesaTerminalDriver* Create();
static VesaTerminalDriver* create();
~VesaTerminalDriver();
virtual uint32_t Width() const override { return m_width / m_font.Width; }
virtual uint32_t Height() const override { return m_height / m_font.Height; }
virtual uint32_t width() const override { return m_width / m_font.Width; }
virtual uint32_t height() const override { return m_height / m_font.Height; }
virtual void PutCharAt(uint16_t, uint32_t, uint32_t, Color, Color) override;
virtual void Clear(Color) override;
virtual void putchar_at(uint16_t, uint32_t, uint32_t, Color, Color) override;
virtual void clear(Color) override;
virtual void SetCursorPosition(uint32_t, uint32_t) override;
virtual void set_cursor_position(uint32_t, uint32_t) override;
private:
VesaTerminalDriver(uint32_t width, uint32_t height, uint32_t pitch, uint8_t bpp, uintptr_t address, bitmap_font font)
@@ -27,7 +27,7 @@ private:
, m_font(font)
{ }
void SetPixel(uint32_t, Color);
void set_pixel(uint32_t, Color);
private:
uint32_t m_width = 0;

4
kernel/include/kernel/kprint.h
View File

@@ -3,5 +3,5 @@
#include <BAN/Formatter.h>
#include <kernel/TTY.h>
#define kprint(...) BAN::Formatter::print(TTY::PutCharCurrent, __VA_ARGS__)
#define kprintln(...) BAN::Formatter::println(TTY::PutCharCurrent, __VA_ARGS__)
#define kprint(...) BAN::Formatter::print(TTY::putchar_current, __VA_ARGS__)
#define kprintln(...) BAN::Formatter::println(TTY::putchar_current, __VA_ARGS__)

84
kernel/kernel/APIC.cpp
View File

@@ -110,7 +110,7 @@ union RedirectionEntry
};
};
static bool IsRSDP(uintptr_t rsdp_addr)
static bool is_rsdp(uintptr_t rsdp_addr)
{
const RSDP* rsdp = (const RSDP*)rsdp_addr;
@@ -137,16 +137,16 @@ static bool IsRSDP(uintptr_t rsdp_addr)
return true;
}
static uintptr_t LocateRSDP()
static uintptr_t locate_rsdp()
{
// Look in main BIOS area below 1 MB
for (uintptr_t addr = 0x000E0000; addr < 0x000FFFFF; addr += 16)
if (IsRSDP(addr))
if (is_rsdp(addr))
return addr;
return 0;
}
static bool IsValidSDTHeader(const SDTHeader* header)
static bool is_valid_std_header(const SDTHeader* header)
{
uint8_t sum = 0;
for (uint32_t i = 0; i < header->length; i++)
@@ -154,7 +154,7 @@ static bool IsValidSDTHeader(const SDTHeader* header)
return sum == 0;
}
uintptr_t LocateMADT(uintptr_t rsdp_addr)
uintptr_t locate_madt(uintptr_t rsdp_addr)
{
uintptr_t entry_address_base = 0;
uintptr_t entry_address_mask = 0;
@@ -165,70 +165,70 @@ uintptr_t LocateMADT(uintptr_t rsdp_addr)
if (rsdp->revision == 2)
{
uintptr_t xsdt_addr = rsdp->v2_xsdt_address;
MMU::Get().AllocatePage(xsdt_addr);
MMU::get().allocate_page(xsdt_addr);
entry_address_base = xsdt_addr + sizeof(SDTHeader);
entry_address_mask = (uintptr_t)0xFFFFFFFFFFFFFFFF;
entry_count = (((const SDTHeader*)xsdt_addr)->length - sizeof(SDTHeader)) / 8;
entry_pointer_size = 8;
MMU::Get().UnAllocatePage(xsdt_addr);
MMU::get().unallocate_page(xsdt_addr);
}
else
{
uintptr_t rsdt_addr = rsdp->rsdt_address;
MMU::Get().AllocatePage(rsdt_addr);
MMU::get().allocate_page(rsdt_addr);
entry_address_base = rsdt_addr + sizeof(SDTHeader);
entry_address_mask = 0xFFFFFFFF;
entry_count = (((const SDTHeader*)rsdt_addr)->length - sizeof(SDTHeader)) / 4;
entry_pointer_size = 4;
MMU::Get().UnAllocatePage(rsdt_addr);
MMU::get().unallocate_page(rsdt_addr);
}
for (uint32_t i = 0; i < entry_count; i++)
{
uintptr_t entry_addr_ptr = entry_address_base + i * entry_pointer_size;
MMU::Get().AllocatePage(entry_addr_ptr);
MMU::get().allocate_page(entry_addr_ptr);
uintptr_t entry_addr = *(uintptr_t*)entry_addr_ptr & entry_address_mask;
MMU::Get().AllocatePage(entry_addr);
MMU::get().allocate_page(entry_addr);
BAN::ScopeGuard _([&]() {
MMU::Get().UnAllocatePage(entry_addr);
MMU::Get().UnAllocatePage(entry_addr_ptr);
MMU::get().unallocate_page(entry_addr);
MMU::get().unallocate_page(entry_addr_ptr);
});
const SDTHeader* entry = (const SDTHeader*)entry_addr;
if (memcmp(entry->signature, "APIC", 4) == 0 && IsValidSDTHeader(entry))
if (memcmp(entry->signature, "APIC", 4) == 0 && is_valid_std_header(entry))
return entry_addr;
}
return 0;
}
APIC* APIC::Create()
APIC* APIC::create()
{
uint32_t ecx, edx;
CPUID::GetFeatures(ecx, edx);
CPUID::get_features(ecx, edx);
if (!(edx & CPUID::Features::EDX_APIC))
{
dprintln("Local APIC is not available");
return nullptr;
}
uintptr_t rsdp_addr = LocateRSDP();
uintptr_t rsdp_addr = locate_rsdp();
if (!rsdp_addr)
{
dprintln("Could not locate RSDP");
return nullptr;
}
uintptr_t madt_addr = LocateMADT(rsdp_addr);
uintptr_t madt_addr = locate_madt(rsdp_addr);
if (!madt_addr)
{
dprintln("Could not find MADT in RSDP");
return nullptr;
}
MMU::Get().AllocatePage(madt_addr);
MMU::get().allocate_page(madt_addr);
const MADT* madt = (const MADT*)madt_addr;
@@ -248,7 +248,7 @@ APIC* APIC::Create()
processor.processor_id = entry->entry0.acpi_processor_id;
processor.apic_id = entry->entry0.apic_id;
processor.flags = entry->entry0.flags & 0x03;
MUST(apic->m_processors.PushBack(processor));
MUST(apic->m_processors.push_back(processor));
break;
case 1:
IOAPIC ioapic;
@@ -256,7 +256,7 @@ APIC* APIC::Create()
ioapic.address = entry->entry1.ioapic_address;
ioapic.gsi_base = entry->entry1.gsi_base;
ioapic.max_redirs = 0;
MUST(apic->m_io_apics.PushBack(ioapic));
MUST(apic->m_io_apics.push_back(ioapic));
break;
case 2:
apic->m_irq_overrides[entry->entry2.irq_source] = entry->entry2.gsi;
@@ -270,25 +270,25 @@ APIC* APIC::Create()
}
madt_entry_addr += entry->length;
}
MMU::Get().UnAllocatePage((uintptr_t)madt);
MMU::get().unallocate_page((uintptr_t)madt);
if (apic->m_local_apic == 0 || apic->m_io_apics.Empty())
if (apic->m_local_apic == 0 || apic->m_io_apics.empty())
{
dprintln("MADT did not provide necessary information");
delete apic;
return nullptr;
}
MMU::Get().AllocatePage(apic->m_local_apic);
MMU::get().allocate_page(apic->m_local_apic);
for (auto& io_apic : apic->m_io_apics)
{
MMU::Get().AllocatePage(io_apic.address);
io_apic.max_redirs = io_apic.Read(IOAPIC_MAX_REDIRS);
MMU::get().allocate_page(io_apic.address);
io_apic.max_redirs = io_apic.read(IOAPIC_MAX_REDIRS);
}
// Mask all interrupts
uint32_t sivr = apic->ReadFromLocalAPIC(LAPIC_SIV_REG);
apic->WriteToLocalAPIC(LAPIC_SIV_REG, sivr | 0x1FF);
uint32_t sivr = apic->read_from_local_apic(LAPIC_SIV_REG);
apic->write_to_local_apic(LAPIC_SIV_REG, sivr | 0x1FF);
#if DEBUG_PRINT_PROCESSORS
for (auto& processor : apic->m_processors)
@@ -302,36 +302,36 @@ APIC* APIC::Create()
return apic;
}
uint32_t APIC::ReadFromLocalAPIC(ptrdiff_t offset)
uint32_t APIC::read_from_local_apic(ptrdiff_t offset)
{
return *(uint32_t*)(m_local_apic + offset);
}
void APIC::WriteToLocalAPIC(ptrdiff_t offset, uint32_t data)
void APIC::write_to_local_apic(ptrdiff_t offset, uint32_t data)
{
*(uint32_t*)(m_local_apic + offset) = data;
}
uint32_t APIC::IOAPIC::Read(uint8_t offset)
uint32_t APIC::IOAPIC::read(uint8_t offset)
{
volatile uint32_t* ioapic = (volatile uint32_t*)address;
ioapic[0] = offset;
return ioapic[4];
}
void APIC::IOAPIC::Write(uint8_t offset, uint32_t data)
void APIC::IOAPIC::write(uint8_t offset, uint32_t data)
{
volatile uint32_t* ioapic = (volatile uint32_t*)address;
ioapic[0] = offset;
ioapic[4] = data;
}
void APIC::EOI(uint8_t)
void APIC::eoi(uint8_t)
{
WriteToLocalAPIC(LAPIC_EIO_REG, 0);
write_to_local_apic(LAPIC_EIO_REG, 0);
}
void APIC::EnableIrq(uint8_t irq)
void APIC::enable_irq(uint8_t irq)
{
uint32_t gsi = m_irq_overrides[irq];
@@ -347,22 +347,22 @@ void APIC::EnableIrq(uint8_t irq)
ASSERT(ioapic);
RedirectionEntry redir;
redir.lo_dword = ioapic->Read(IOAPIC_REDIRS + gsi * 2);
redir.hi_dword = ioapic->Read(IOAPIC_REDIRS + gsi * 2 + 1);
redir.lo_dword = ioapic->read(IOAPIC_REDIRS + gsi * 2);
redir.hi_dword = ioapic->read(IOAPIC_REDIRS + gsi * 2 + 1);
redir.vector = IRQ_VECTOR_BASE + irq;
redir.mask = 0;
redir.destination = m_processors.Front().apic_id;
redir.destination = m_processors.front().apic_id;
ioapic->Write(IOAPIC_REDIRS + gsi * 2, redir.lo_dword);
ioapic->Write(IOAPIC_REDIRS + gsi * 2 + 1, redir.hi_dword);
ioapic->write(IOAPIC_REDIRS + gsi * 2, redir.lo_dword);
ioapic->write(IOAPIC_REDIRS + gsi * 2 + 1, redir.hi_dword);
}
bool APIC::IsInService(uint8_t irq)
bool APIC::is_in_service(uint8_t irq)
{
uint32_t dword = (irq + IRQ_VECTOR_BASE) / 32;
uint32_t bit = (irq + IRQ_VECTOR_BASE) % 32;
uint32_t isr = ReadFromLocalAPIC(LAPIC_IS_REG + dword * 0x10);
uint32_t isr = read_from_local_apic(LAPIC_IS_REG + dword * 0x10);
return isr & (1 << bit);
}

10
kernel/kernel/CPUID.cpp
View File

@@ -12,7 +12,7 @@ namespace CPUID
asm volatile ("cpuid": "=a"(out[0]), "=b"(out[0]), "=d"(out[1]), "=c"(out[2]) : "a"(code));
}
const char* GetVendor()
const char* get_vendor()
{
static char vendor[13] {};
get_cpuid_string(0x00, (uint32_t*)vendor);
@@ -20,7 +20,7 @@ namespace CPUID
return vendor;
}
void GetFeatures(uint32_t& ecx, uint32_t& edx)
void get_features(uint32_t& ecx, uint32_t& edx)
{
uint32_t buffer[4] {};
get_cpuid(0x01, buffer);
@@ -28,7 +28,7 @@ namespace CPUID
edx = buffer[3];
}
bool Is64Bit()
bool is_64_bit()
{
uint32_t buffer[4] {};
get_cpuid(0x80000000, buffer);
@@ -39,7 +39,7 @@ namespace CPUID
return buffer[3] & (1 << 29);
}
const char* FeatStringECX(uint32_t feat)
const char* feature_string_ecx(uint32_t feat)
{
switch (feat)
{
@@ -78,7 +78,7 @@ namespace CPUID
}
}
const char* FeatStringEDX(uint32_t feat)
const char* feature_string_edx(uint32_t feat)
{
switch (feat)
{

8
kernel/kernel/Debug.cpp
View File

@@ -5,7 +5,7 @@
namespace Debug
{
void DumpStackTrace()
void dump_stack_trace()
{
struct stackframe
{
@@ -37,10 +37,10 @@ namespace Debug
void putchar(char ch)
{
if (Serial::IsInitialized())
if (Serial::is_initialized())
return Serial::putchar(ch);
if (TTY::IsInitialized())
return TTY::PutCharCurrent(ch);
if (TTY::is_initialized())
return TTY::putchar_current(ch);
}
}

84
kernel/kernel/Input.cpp
View File

@@ -207,9 +207,9 @@ namespace Input
{
bool waiting_response = false;
if (!s_command_queue.Empty())
if (!s_command_queue.empty())
{
auto& command = s_command_queue.Front();
auto& command = s_command_queue.front();
if (command.target == target && command._sent && !command._done)
waiting_response = true;
}
@@ -218,7 +218,7 @@ namespace Input
{
if (waiting_response)
{
auto& command = s_command_queue.Front();
auto& command = s_command_queue.front();
if (raw == I8042_KB_RESEND)
{
@@ -241,7 +241,7 @@ namespace Input
}
else if (raw == 0xEE && command.command == 0xEE)
{
s_command_queue.Pop();
s_command_queue.pop();
}
else
{
@@ -261,7 +261,7 @@ namespace Input
{
if (waiting_response)
{
auto& command = s_command_queue.Front();
auto& command = s_command_queue.front();
if (raw == I8042_MOUSE_ACK)
{
@@ -288,9 +288,9 @@ namespace Input
bool right = s_mouse_data_buffer[0] & (1 << 1);
bool middle = s_mouse_data_buffer[0] & (1 << 2);
if (left) MUST(s_mouse_button_event_queue.Push({ .button = MouseButton::Left }));
if (right) MUST(s_mouse_button_event_queue.Push({ .button = MouseButton::Right }));
if (middle) MUST(s_mouse_button_event_queue.Push({ .button = MouseButton::Middle }));
if (left) MUST(s_mouse_button_event_queue.push({ .button = MouseButton::Left }));
if (right) MUST(s_mouse_button_event_queue.push({ .button = MouseButton::Right }));
if (middle) MUST(s_mouse_button_event_queue.push({ .button = MouseButton::Middle }));
}
if (s_mouse_data_buffer[1] || s_mouse_data_buffer[2])
@@ -298,7 +298,7 @@ namespace Input
int16_t rel_x = (int16_t)s_mouse_data_buffer[1] - ((s_mouse_data_buffer[0] << 4) & 0x100);
int16_t rel_y = (int16_t)s_mouse_data_buffer[2] - ((s_mouse_data_buffer[0] << 3) & 0x100);
MUST(s_mouse_move_event_queue.Push({ .dx = rel_x, .dy = rel_y }));
MUST(s_mouse_move_event_queue.push({ .dx = rel_x, .dy = rel_y }));
}
s_mouse_data_buffer_index = 0;
@@ -307,35 +307,35 @@ namespace Input
}
else
{
Kernel::Panic("Unknown target");
Kernel::panic("Unknown target");
}
}
void update()
{
if (!s_command_queue.Empty())
if (!s_command_queue.empty())
{
auto& command = s_command_queue.Front();
auto& command = s_command_queue.front();
if (command.target != TARGET_KEYBOARD && command.target != TARGET_MOUSE)
Kernel::Panic("Undefined target for command 0x{2H}", command.command);
Kernel::panic("Undefined target for command 0x{2H}", command.command);
if (command._sent == 0 && command._ack == 0)
{
command._sent++;
if (!i8042_command(command.target, command.command))
Kernel::Panic("PS/2 command oof {}, 0x{2H}", command.target, command.command);
Kernel::panic("PS/2 command oof {}, 0x{2H}", command.target, command.command);
}
if (command._sent == 1 && command._ack == 1 && command.has_data)
{
command._sent++;
if (!i8042_command(command.target, command.data))
Kernel::Panic("PS/2 data oof {}, 0x{2H}", command.target, command.data);
Kernel::panic("PS/2 data oof {}, 0x{2H}", command.target, command.data);
}
if (command._sent > 0 && PIT::ms_since_boot() > s_command_sent + 1000)
{
kprintln("PS/2 command 0x{2H} timed out on {}", command.command, command.target);
dprintln("PS/2 command 0x{2H} timed out on {}", command.command, command.target);
// Discard command on timeout?
command._done = true;
command.target = 0;
@@ -349,14 +349,14 @@ namespace Input
{
case I8042_KB_RESET:
if (s_command_response[0] != I8042_KB_SELF_TEST_PASS)
Kernel::Panic("PS/2 Keyboard self test failed");
Kernel::panic("PS/2 Keyboard self test failed");
break;
case I8042_KB_SET_SCAN_CODE_SET:
break;
case I8042_KB_SET_LEDS:
break;
default:
Kernel::Panic("PS/2 Keyboard unhandled command");
Kernel::panic("PS/2 Keyboard unhandled command");
}
}
else if (command.target == TARGET_MOUSE)
@@ -365,43 +365,43 @@ namespace Input
{
case I8042_MOUSE_RESET:
if (s_command_response[0] != I8042_MOUSE_SELF_TEST_PASS)
Kernel::Panic("PS/2 Mouse self test failed");
Kernel::panic("PS/2 Mouse self test failed");
if (s_command_response[1] != 0x00)
Kernel::Panic("PS/2 Mouse invalid byte sent after self test");
Kernel::panic("PS/2 Mouse invalid byte sent after self test");
break;
case I8042_MOUSE_ENABLE:
break;
case I8042_MOUSE_DISABLE:
break;
default:
Kernel::Panic("PS/2 Mouse unhandled command");
Kernel::panic("PS/2 Mouse unhandled command");
}
}
s_command_response_index = 0;
s_command_queue.Pop();
s_command_queue.pop();
}
}
while (!s_key_event_queue.Empty())
while (!s_key_event_queue.empty())
{
if (s_key_event_callback)
s_key_event_callback(s_key_event_queue.Front());
s_key_event_queue.Pop();
s_key_event_callback(s_key_event_queue.front());
s_key_event_queue.pop();
}
while (!s_mouse_button_event_queue.Empty())
while (!s_mouse_button_event_queue.empty())
{
if (s_mouse_button_event_callback)
s_mouse_button_event_callback(s_mouse_button_event_queue.Front());
s_mouse_button_event_queue.Pop();
s_mouse_button_event_callback(s_mouse_button_event_queue.front());
s_mouse_button_event_queue.pop();
}
while (!s_mouse_move_event_queue.Empty())
while (!s_mouse_move_event_queue.empty())
{
if (s_mouse_move_event_callback)
s_mouse_move_event_callback(s_mouse_move_event_queue.Front());
s_mouse_move_event_queue.Pop();
s_mouse_move_event_callback(s_mouse_move_event_queue.front());
s_mouse_move_event_queue.pop();
}
}
@@ -487,7 +487,7 @@ namespace Input
if (update_leds)
{
MUST(s_command_queue.Push({
MUST(s_command_queue.push({
.target = TARGET_KEYBOARD,
.command = I8042_KB_SET_LEDS,
.data = s_led_states,
@@ -510,9 +510,9 @@ namespace Input
if (key != Key::INVALID)
{
auto error_or = s_key_event_queue.Push({ .key = key, .modifiers = modifiers, .pressed = pressed });
if (error_or.IsError())
dwarnln("{}", error_or.GetError());
auto error_or = s_key_event_queue.push({ .key = key, .modifiers = modifiers, .pressed = pressed });
if (error_or.is_error())
dwarnln("{}", error_or.get_error());
}
s_keyboard_key_buffer_size -= index + 1;
memmove(s_keyboard_key_buffer, s_keyboard_key_buffer + index, s_keyboard_key_buffer_size);
@@ -540,17 +540,17 @@ namespace Input
{
// Register callback and IRQ
IDT::register_irq_handler(KEYBOARD_IRQ, keyboard_irq_handler);
InterruptController::Get().EnableIrq(KEYBOARD_IRQ);
InterruptController::get().enable_irq(KEYBOARD_IRQ);
i8042_controller_command(I8042_ENABLE_FIRST_PORT);
MUST(s_command_queue.Push({
MUST(s_command_queue.push({
.target = TARGET_KEYBOARD,
.command = I8042_KB_RESET,
.resp_cnt = 1,
}));
// Set scan code set 2
MUST(s_command_queue.Push({
MUST(s_command_queue.push({
.target = TARGET_KEYBOARD,
.command = I8042_KB_SET_SCAN_CODE_SET,
.data = 0x02,
@@ -558,7 +558,7 @@ namespace Input
}));
// Turn LEDs off
MUST(s_command_queue.Push({
MUST(s_command_queue.push({
.target = TARGET_KEYBOARD,
.command = I8042_KB_SET_LEDS,
.data = s_led_states,
@@ -570,17 +570,17 @@ namespace Input
{
// Register callback and IRQ
IDT::register_irq_handler(MOUSE_IRQ, mouse_irq_handler);
InterruptController::Get().EnableIrq(MOUSE_IRQ);
InterruptController::get().enable_irq(MOUSE_IRQ);
i8042_controller_command(I8042_ENABLE_SECOND_PORT);
MUST(s_command_queue.Push({
MUST(s_command_queue.push({
.target = TARGET_MOUSE,
.command = I8042_MOUSE_RESET,
.resp_cnt = 2,
}));
// Mouse should be disabled when sending commands
MUST(s_command_queue.Push({
MUST(s_command_queue.push({
.target = TARGET_MOUSE,
.command = I8042_MOUSE_ENABLE,
}));

12
kernel/kernel/InterruptController.cpp
View File

@@ -5,23 +5,23 @@
static InterruptController* s_instance = nullptr;
InterruptController& InterruptController::Get()
InterruptController& InterruptController::get()
{
ASSERT(s_instance);
return *s_instance;
}
void InterruptController::Initialize(bool force_pic)
void InterruptController::initialize(bool force_pic)
{
ASSERT(s_instance == nullptr);
PIC::MaskAll();
PIC::Remap();
PIC::mask_all();
PIC::remap();
if (!force_pic)
s_instance = APIC::Create();
s_instance = APIC::create();
if (s_instance)
return;
dprintln("Using PIC instead of APIC");
s_instance = PIC::Create();
s_instance = PIC::create();
}

16
kernel/kernel/PIC.cpp
View File

@@ -26,14 +26,14 @@
#define ICW4_BUF_MASTER 0x0C /* Buffered mode/master */
#define ICW4_SFNM 0x10 /* Special fully nested (not) */
PIC* PIC::Create()
PIC* PIC::create()
{
MaskAll();
Remap();
mask_all();
remap();
return new PIC;
}
void PIC::Remap()
void PIC::remap()
{
uint8_t a1 = IO::inb(PIC1_DATA);
uint8_t a2 = IO::inb(PIC2_DATA);
@@ -67,20 +67,20 @@ void PIC::Remap()
IO::outb(PIC2_DATA, a2);
}
void PIC::MaskAll()
void PIC::mask_all()
{
IO::outb(PIC1_DATA, 0xFF);
IO::outb(PIC2_DATA, 0xFF);
}
void PIC::EOI(uint8_t irq)
void PIC::eoi(uint8_t irq)
{
if (irq >= 8)
IO::outb(PIC2_COMMAND, PIC_EOI);
IO::outb(PIC1_COMMAND, PIC_EOI);
}
void PIC::EnableIrq(uint8_t irq)
void PIC::enable_irq(uint8_t irq)
{
uint16_t port;
uint8_t value;
@@ -98,7 +98,7 @@ void PIC::EnableIrq(uint8_t irq)
IO::outb(port, value);
}
bool PIC::IsInService(uint8_t irq)
bool PIC::is_in_service(uint8_t irq)
{
uint16_t port = irq < 8 ? PIC1_COMMAND : PIC2_COMMAND;
uint8_t bit = irq < 8 ? irq : irq - 8;

4
kernel/kernel/PIT.cpp
View File

@@ -28,7 +28,7 @@ namespace PIT
void irq_handler()
{
s_system_time++;
Kernel::Scheduler::Get().Switch();
Kernel::Scheduler::get().switch_thread();
}
uint64_t ms_since_boot()
@@ -47,7 +47,7 @@ namespace PIT
IDT::register_irq_handler(PIT_IRQ, irq_handler);
InterruptController::Get().EnableIrq(PIT_IRQ);
InterruptController::get().enable_irq(PIT_IRQ);
}
}

2
kernel/kernel/RTC.cpp
View File

@@ -44,7 +44,7 @@ namespace RTC
out.year = get_rtc_register(CMOS_REGISTER_YEAR);
}
BAN::Time GetCurrentTime()
BAN::Time get_current_time()
{
BAN::Time last_time = {};
BAN::Time time = {};

2
kernel/kernel/SSP.cpp
View File

@@ -16,7 +16,7 @@ __BEGIN_DECLS
__attribute__((noreturn))
void __stack_chk_fail(void)
{
Kernel::Panic("Stack smashing detected");
Kernel::panic("Stack smashing detected");
abort();
}

33
kernel/kernel/Scheduler.cpp
View File

@@ -20,40 +20,38 @@ namespace Kernel
#endif
);
void Scheduler::Initialize()
void Scheduler::initialize()
{
ASSERT(!s_instance);
s_instance = new Scheduler();
}
Scheduler& Scheduler::Get()
Scheduler& Scheduler::get()
{
ASSERT(s_instance);
return *s_instance;
}
const Thread& Scheduler::CurrentThread() const
const Thread& Scheduler::current_thread() const
{
return *m_current_iterator;
}
void Scheduler::AddThread(void(*thread)())
{
MUST(m_threads.EmplaceBack(thread));
if (!m_current_iterator)
m_current_iterator = m_threads.begin();
}
//void Scheduler::AddThread(const BAN::Function<void()>& function)
//{
// MUST(m_threads.EmplaceBack(function));
//}
void Scheduler::Switch()
void Scheduler::switch_thread()
{
static uint8_t cnt = 0;
if (cnt++ % ms_between_switch)
return;
ASSERT(InterruptController::Get().IsInService(PIT_IRQ));
ASSERT(InterruptController::get().is_in_service(PIT_IRQ));
ASSERT(m_threads.Size() > 0);
if (m_threads.Size() == 1)
ASSERT(m_threads.size() > 0);
if (m_threads.size() == 1)
return;
ASSERT(m_current_iterator);
@@ -69,7 +67,7 @@ namespace Kernel
{
// NOTE: this does not invalidate the next/next_iterator
// since we are working with linked list
m_threads.Remove(m_current_iterator);
m_threads.remove(m_current_iterator);
m_current_iterator = decltype(m_threads)::iterator();
}
@@ -127,10 +125,11 @@ namespace Kernel
ASSERT(false);
}
void Scheduler::Start()
void Scheduler::start()
{
ASSERT(m_threads.Size() > 0);
ASSERT(m_current_iterator);
ASSERT(m_threads.size() > 0);
m_current_iterator = m_threads.begin();
Thread& current = *m_current_iterator;
ASSERT(current.state() == Thread::State::NotStarted);

4
kernel/kernel/Serial.cpp
View File

@@ -8,7 +8,7 @@ namespace Serial
static bool s_initialized = false;
void Initialize()
void initialize()
{
IO::outb(COM1_PORT + 1, 0x00); // Disable all interrupts
IO::outb(COM1_PORT + 3, 0x80); // Enable DLAB (set baud rate divisor)
@@ -30,7 +30,7 @@ namespace Serial
s_initialized = true;
}
bool IsInitialized()
bool is_initialized()
{
return s_initialized;
}

216
kernel/kernel/Shell.cpp
View File

@@ -6,12 +6,13 @@
#include <kernel/IO.h>
#include <kernel/PIT.h>
#include <kernel/RTC.h>
#include <kernel/Scheduler.h>
#include <kernel/Shell.h>
#include <ctype.h>
#define TTY_PRINT(...) Formatter::print([this](char c) { m_tty->PutChar(c); }, __VA_ARGS__)
#define TTY_PRINTLN(...) Formatter::println([this](char c) { m_tty->PutChar(c); }, __VA_ARGS__)
#define TTY_PRINT(...) Formatter::print([this](char c) { m_tty->putchar(c); }, __VA_ARGS__)
#define TTY_PRINTLN(...) Formatter::println([this](char c) { m_tty->putchar(c); }, __VA_ARGS__)
namespace Kernel
{
@@ -22,20 +23,20 @@ namespace Kernel
Shell::Shell(TTY* tty)
: m_tty(tty)
{
Input::register_key_event_callback({ &Shell::KeyEventCallback, this });
SetPrompt(s_default_prompt);
MUST(m_buffer.PushBack(""_sv));
Input::register_key_event_callback({ &Shell::key_event_callback, this });
set_prompt(s_default_prompt);
MUST(m_buffer.push_back(""_sv));
}
void Shell::SetPrompt(StringView prompt)
void Shell::set_prompt(StringView prompt)
{
m_prompt_length = 0;
m_prompt = String();
bool skipping = false;
for (size_t i = 0; i < prompt.Size(); i++)
for (size_t i = 0; i < prompt.size(); i++)
{
if (i < prompt.Size() - 1 && prompt[i] == '\\')
if (i < prompt.size() - 1 && prompt[i] == '\\')
{
if (prompt[i + 1] == '[')
skipping = true;
@@ -45,13 +46,13 @@ namespace Kernel
continue;
}
MUST(m_prompt.PushBack(prompt[i]));
MUST(m_prompt.push_back(prompt[i]));
if (!skipping)
m_prompt_length++;
}
}
void Shell::Run()
void Shell::run()
{
TTY_PRINT("{}", m_prompt);
for (;;)
@@ -61,25 +62,25 @@ namespace Kernel
}
}
Vector<String> Shell::ParseArguments(StringView command) const
Vector<String> Shell::parse_arguments(StringView command) const
{
Vector<String> result;
while (!command.Empty())
while (!command.empty())
{
while (!command.Empty() && isspace(command.Front()))
command = command.Substring(1);
while (!command.empty() && isspace(command.front()))
command = command.substring(1);
if (command.Empty())
if (command.empty())
break;
MUST(result.PushBack(""_sv));
MUST(result.push_back(""_sv));
char quoted = '\0';
bool escape = false;
while (!command.Empty())
while (!command.empty())
{
char ch = command.Front();
char ch = command.front();
switch (ch)
{
case '"':
@@ -104,28 +105,28 @@ default_case:
{
switch (ch)
{
case 'f': MUST(result.Back().PushBack('\f')); break;
case 'n': MUST(result.Back().PushBack('\n')); break;
case 'r': MUST(result.Back().PushBack('\r')); break;
case 't': MUST(result.Back().PushBack('\t')); break;
case 'v': MUST(result.Back().PushBack('\v')); break;
case '"': MUST(result.Back().PushBack('"')); break;
case '\'': MUST(result.Back().PushBack('\'')); break;
case '\\': MUST(result.Back().PushBack('\\')); break;
case 'f': MUST(result.back().push_back('\f')); break;
case 'n': MUST(result.back().push_back('\n')); break;
case 'r': MUST(result.back().push_back('\r')); break;
case 't': MUST(result.back().push_back('\t')); break;
case 'v': MUST(result.back().push_back('\v')); break;
case '"': MUST(result.back().push_back('"')); break;
case '\'': MUST(result.back().push_back('\'')); break;
case '\\': MUST(result.back().push_back('\\')); break;
default:
char buffer[3] { '\\', ch, '\0' };
MUST(result.Back().Append(buffer));
MUST(result.back().append(buffer));
break;
}
}
else
{
MUST(result.Back().PushBack(ch));
MUST(result.back().push_back(ch));
}
escape = false;
break;
}
command = command.Substring(1);
command = command.substring(1);
}
argument_done:
continue;
@@ -134,93 +135,119 @@ argument_done:
return result;
}
void Shell::ProcessCommand(const Vector<String>& arguments)
void Shell::process_command(const Vector<String>& arguments)
{
if (arguments.Empty())
if (arguments.empty())
{
}
else if (arguments.Front() == "date")
else if (arguments.front() == "date")
{
if (arguments.Size() != 1)
if (arguments.size() != 1)
{
TTY_PRINTLN("'date' does not support command line arguments");
return;
}
auto time = RTC::GetCurrentTime();
auto time = RTC::get_current_time();
TTY_PRINTLN("{}", time);
}
else if (arguments.Front() == "echo")
else if (arguments.front() == "echo")
{
if (arguments.Size() > 1)
if (arguments.size() > 1)
{
TTY_PRINT("{}", arguments[1]);
for (size_t i = 2; i < arguments.Size(); i++)
for (size_t i = 2; i < arguments.size(); i++)
TTY_PRINT(" {}", arguments[i]);
}
TTY_PRINTLN("");
}
else if (arguments.Front() == "clear")
else if (arguments.front() == "clear")
{
if (arguments.Size() != 1)
if (arguments.size() != 1)
{
TTY_PRINTLN("'clear' does not support command line arguments");
return;
}
m_tty->Clear();
m_tty->SetCursorPosition(0, 0);
m_tty->clear();
m_tty->set_cursor_position(0, 0);
}
else if (arguments.Front() == "time")
else if (arguments.front() == "time")
{
auto new_args = arguments;
new_args.Remove(0);
new_args.remove(0);
auto start = PIT::ms_since_boot();
ProcessCommand(new_args);
process_command(new_args);
auto duration = PIT::ms_since_boot() - start;
TTY_PRINTLN("took {} ms", duration);
}
else if (arguments.Front() == "memory")
else if (arguments.front() == "thread")
{
if (arguments.Size() != 1)
if (arguments.size() != 1)
{
TTY_PRINTLN("'thread' does not support command line arguments");
return;
}
//Scheduler::Get().AddThread(
// [this, arguments]()
// {
// auto start = PIT::ms_since_boot();
// while (PIT::ms_since_boot() < start + 5000);
// auto copy = arguments;
// copy.remove(0);
// ProcessCommand(copy);
// }
//);
Scheduler::get().add_thread(BAN::Function<void()>(
[this]()
{
auto start = PIT::ms_since_boot();
while (PIT::ms_since_boot() < start + 3000);
TTY_PRINTLN("hello");
}
));
}
else if (arguments.front() == "memory")
{
if (arguments.size() != 1)
{
TTY_PRINTLN("'memory' does not support command line arguments");
return;
}
kmalloc_dump_info();
}
else if (arguments.Front() == "cpuinfo")
else if (arguments.front() == "cpuinfo")
{
if (arguments.Size() != 1)
if (arguments.size() != 1)
{
TTY_PRINTLN("'cpuinfo' does not support command line arguments");
return;
}
uint32_t ecx, edx;
auto vendor = CPUID::GetVendor();
CPUID::GetFeatures(ecx, edx);
auto vendor = CPUID::get_vendor();
CPUID::get_features(ecx, edx);
TTY_PRINTLN("Vendor: '{}'", vendor);
TTY_PRINTLN("64-bit: {}", CPUID::Is64Bit());
TTY_PRINTLN("64-bit: {}", CPUID::is_64_bit());
bool first = true;
for (int i = 0; i < 32; i++)
if (ecx & ((uint32_t)1 << i))
TTY_PRINT("{}{}", first ? (first = false, "") : ", ", CPUID::FeatStringECX((uint32_t)1 << i));
TTY_PRINT("{}{}", first ? (first = false, "") : ", ", CPUID::feature_string_ecx((uint32_t)1 << i));
for (int i = 0; i < 32; i++)
if (edx & ((uint32_t)1 << i))
TTY_PRINT("{}{}", first ? (first = false, "") : ", ", CPUID::FeatStringEDX((uint32_t)1 << i));
TTY_PRINT("{}{}", first ? (first = false, "") : ", ", CPUID::feature_string_edx((uint32_t)1 << i));
if (!first)
TTY_PRINTLN("");
}
else if (arguments.Front() == "random")
else if (arguments.front() == "random")
{
if (arguments.Size() != 1)
if (arguments.size() != 1)
{
TTY_PRINTLN("'random' does not support command line arguments");
return;
}
uint32_t ecx, edx;
CPUID::GetFeatures(ecx, edx);
CPUID::get_features(ecx, edx);
if (!(ecx & CPUID::Features::ECX_RDRND))
{
TTY_PRINTLN("cpu does not support RDRAND instruction");
@@ -234,9 +261,9 @@ argument_done:
TTY_PRINTLN(" 0x{8H}", random);
}
}
else if (arguments.Front() == "reboot")
else if (arguments.front() == "reboot")
{
if (arguments.Size() != 1)
if (arguments.size() != 1)
{
TTY_PRINTLN("'reboot' does not support command line arguments");
return;
@@ -249,36 +276,36 @@ argument_done:
}
else
{
TTY_PRINTLN("unrecognized command '{}'", arguments.Front());
TTY_PRINTLN("unrecognized command '{}'", arguments.front());
}
}
void Shell::ReRenderBuffer() const
void Shell::rerender_buffer() const
{
TTY_PRINT("\e[{}G{}\e[K", m_prompt_length + 1, m_buffer[m_cursor_pos.line]);
}
static uint32_t GetLastLength(StringView sv)
static uint32_t get_last_length(StringView sv)
{
if (sv.Size() >= 2 && ((uint8_t)sv[sv.Size() - 2] >> 5) == 0b110) return 2;
if (sv.Size() >= 3 && ((uint8_t)sv[sv.Size() - 3] >> 4) == 0b1110) return 3;
if (sv.Size() >= 4 && ((uint8_t)sv[sv.Size() - 4] >> 3) == 0b11110) return 4;
return Math::min<uint32_t>(sv.Size(), 1);
if (sv.size() >= 2 && ((uint8_t)sv[sv.size() - 2] >> 5) == 0b110) return 2;
if (sv.size() >= 3 && ((uint8_t)sv[sv.size() - 3] >> 4) == 0b1110) return 3;
if (sv.size() >= 4 && ((uint8_t)sv[sv.size() - 4] >> 3) == 0b11110) return 4;
return Math::min<uint32_t>(sv.size(), 1);
}
static uint32_t GetNextLength(StringView sv)
static uint32_t get_next_length(StringView sv)
{
if (sv.Size() >= 2 && ((uint8_t)sv[0] >> 5) == 0b110) return 2;
if (sv.Size() >= 3 && ((uint8_t)sv[0] >> 4) == 0b1110) return 3;
if (sv.Size() >= 4 && ((uint8_t)sv[0] >> 3) == 0b11110) return 4;
return Math::min<uint32_t>(sv.Size(), 1);
if (sv.size() >= 2 && ((uint8_t)sv[0] >> 5) == 0b110) return 2;
if (sv.size() >= 3 && ((uint8_t)sv[0] >> 4) == 0b1110) return 3;
if (sv.size() >= 4 && ((uint8_t)sv[0] >> 3) == 0b11110) return 4;
return Math::min<uint32_t>(sv.size(), 1);
}
static uint32_t GetUnicodeCharacterCount(StringView sv)
static uint32_t get_unicode_character_count(StringView sv)
{
uint32_t len = 0;
for (uint32_t i = 0; i < sv.Size(); i++)
for (uint32_t i = 0; i < sv.size(); i++)
{
uint8_t ch = sv[i];
if ((ch >> 5) == 0b110) i += 1;
@@ -289,7 +316,7 @@ argument_done:
return len;
}
void Shell::KeyEventCallback(Input::KeyEvent event)
void Shell::key_event_callback(Input::KeyEvent event)
{
if (!event.pressed)
return;
@@ -301,11 +328,11 @@ argument_done:
case Input::Key::Backspace:
if (m_cursor_pos.col > 0)
{
TTY_PRINT("\e[D{} ", current_buffer.SV().Substring(m_cursor_pos.index));
TTY_PRINT("\e[D{} ", current_buffer.sv().substring(m_cursor_pos.index));
uint32_t len = GetLastLength(current_buffer.SV().Substring(0, m_cursor_pos.index));
uint32_t len = get_last_length(current_buffer.sv().substring(0, m_cursor_pos.index));
m_cursor_pos.index -= len;
current_buffer.Erase(m_cursor_pos.index, len);
current_buffer.erase(m_cursor_pos.index, len);
m_cursor_pos.col--;
}
break;
@@ -314,15 +341,14 @@ argument_done:
case Input::Key::NumpadEnter:
{
TTY_PRINTLN("");
auto arguments = ParseArguments(current_buffer.SV());
if (!arguments.Empty())
auto arguments = parse_arguments(current_buffer.sv());
if (!arguments.empty())
{
ProcessCommand(arguments);
MUST(m_old_buffer.PushBack(current_buffer));
process_command(arguments);
MUST(m_old_buffer.push_back(current_buffer));
m_buffer = m_old_buffer;
MUST(m_buffer.PushBack(""_sv));
MUST(m_buffer.Back().Reserve(128));
m_cursor_pos.line = m_buffer.Size() - 1;
MUST(m_buffer.push_back(""_sv));
m_cursor_pos.line = m_buffer.size() - 1;
}
m_cursor_pos.col = 0;
m_cursor_pos.index = 0;
@@ -340,16 +366,16 @@ argument_done:
case Input::Key::Left:
if (m_cursor_pos.index > 0)
{
uint32_t len = GetLastLength(current_buffer.SV().Substring(0, m_cursor_pos.index));
uint32_t len = get_last_length(current_buffer.sv().substring(0, m_cursor_pos.index));
m_cursor_pos.index -= len;
m_cursor_pos.col--;
}
break;
case Input::Key::Right:
if (m_cursor_pos.index < current_buffer.Size())
if (m_cursor_pos.index < current_buffer.size())
{
uint32_t len = GetNextLength(current_buffer.SV().Substring(m_cursor_pos.index));
uint32_t len = get_next_length(current_buffer.sv().substring(m_cursor_pos.index));
m_cursor_pos.index += len;
m_cursor_pos.col++;
}
@@ -360,20 +386,20 @@ argument_done:
{
const auto& new_buffer = m_buffer[m_cursor_pos.line - 1];
m_cursor_pos.line--;
m_cursor_pos.index = new_buffer.Size();
m_cursor_pos.col = GetUnicodeCharacterCount(new_buffer);
ReRenderBuffer();
m_cursor_pos.index = new_buffer.size();
m_cursor_pos.col = get_unicode_character_count(new_buffer);
rerender_buffer();
}
break;
case Input::Key::Down:
if (m_cursor_pos.line < m_buffer.Size() - 1)
if (m_cursor_pos.line < m_buffer.size() - 1)
{
const auto& new_buffer = m_buffer[m_cursor_pos.line + 1];
m_cursor_pos.line++;
m_cursor_pos.index = new_buffer.Size();
m_cursor_pos.col = GetUnicodeCharacterCount(new_buffer);
ReRenderBuffer();
m_cursor_pos.index = new_buffer.size();
m_cursor_pos.col = get_unicode_character_count(new_buffer);
rerender_buffer();
}
break;
@@ -382,8 +408,8 @@ argument_done:
const char* utf8 = Input::key_event_to_utf8(event);
if (utf8)
{
TTY_PRINT("{}{}", utf8, current_buffer.SV().Substring(m_cursor_pos.index));
MUST(current_buffer.Insert(utf8, m_cursor_pos.index));
TTY_PRINT("{}{}", utf8, current_buffer.sv().substring(m_cursor_pos.index));
MUST(current_buffer.insert(utf8, m_cursor_pos.index));
m_cursor_pos.index += strlen(utf8);
m_cursor_pos.col++;
}

92
kernel/kernel/TTY.cpp
View File

@@ -25,8 +25,8 @@ static TTY* s_tty = nullptr;
TTY::TTY(TerminalDriver* driver)
: m_terminal_driver(driver)
{
m_width = m_terminal_driver->Width();
m_height = m_terminal_driver->Height();
m_width = m_terminal_driver->width();
m_height = m_terminal_driver->height();
m_buffer = new Cell[m_width * m_height];
@@ -34,20 +34,20 @@ TTY::TTY(TerminalDriver* driver)
s_tty = this;
}
void TTY::Clear()
void TTY::clear()
{
for (uint32_t i = 0; i < m_width * m_height; i++)
m_buffer[i] = { .foreground = m_foreground, .background = m_background, .character = ' ' };
m_terminal_driver->Clear(m_background);
m_terminal_driver->clear(m_background);
}
void TTY::SetCursorPosition(uint32_t x, uint32_t y)
void TTY::set_cursor_position(uint32_t x, uint32_t y)
{
static uint32_t last_x = -1;
static uint32_t last_y = -1;
if (last_x != uint32_t(-1) && last_y != uint32_t(-1))
RenderFromBuffer(last_x, last_y); // Hacky way to clear previous cursor in graphics mode :D
m_terminal_driver->SetCursorPosition(x, y);
render_from_buffer(last_x, last_y); // Hacky way to clear previous cursor in graphics mode :D
m_terminal_driver->set_cursor_position(x, y);
last_x = m_column = x;
last_y = m_row = y;
}
@@ -99,7 +99,7 @@ static uint16_t handle_unicode(uint8_t ch)
return ch & 0x7F;
}
void TTY::ResetAnsiEscape()
void TTY::reset_ansi_escape()
{
m_ansi_state.mode = '\0';
m_ansi_state.index = 0;
@@ -107,7 +107,7 @@ void TTY::ResetAnsiEscape()
m_ansi_state.nums[1] = -1;
}
void TTY::HandleAnsiSGR()
void TTY::handle_ansi_sgr()
{
switch (m_ansi_state.nums[0])
{
@@ -137,7 +137,7 @@ void TTY::HandleAnsiSGR()
}
}
void TTY::HandleAnsiEscape(uint16_t ch)
void TTY::handle_ansi_escape(uint16_t ch)
{
switch (m_ansi_state.mode)
{
@@ -148,7 +148,7 @@ void TTY::HandleAnsiEscape(uint16_t ch)
m_ansi_state.mode = CSI;
return;
}
return ResetAnsiEscape();
return reset_ansi_escape();
}
case CSI:
@@ -169,39 +169,39 @@ void TTY::HandleAnsiEscape(uint16_t ch)
if (m_ansi_state.nums[0] == -1)
m_ansi_state.nums[0] = 1;
m_row = max<int32_t>(m_row - m_ansi_state.nums[0], 0);
return ResetAnsiEscape();
return reset_ansi_escape();
case 'B': // Curson Down
if (m_ansi_state.nums[0] == -1)
m_ansi_state.nums[0] = 1;
m_row = min<int32_t>(m_row + m_ansi_state.nums[0], m_height - 1);
return ResetAnsiEscape();
return reset_ansi_escape();
case 'C': // Cursor Forward
if (m_ansi_state.nums[0] == -1)
m_ansi_state.nums[0] = 1;
m_column = min<int32_t>(m_column + m_ansi_state.nums[0], m_width - 1);
return ResetAnsiEscape();
return reset_ansi_escape();
case 'D': // Cursor Back
if (m_ansi_state.nums[0] == -1)
m_ansi_state.nums[0] = 1;
m_column = max<int32_t>(m_column - m_ansi_state.nums[0], 0);
return ResetAnsiEscape();
return reset_ansi_escape();
case 'E': // Cursor Next Line
if (m_ansi_state.nums[0] == -1)
m_ansi_state.nums[0] = 1;
m_row = min<int32_t>(m_row + m_ansi_state.nums[0], m_height - 1);
m_column = 0;
return ResetAnsiEscape();
return reset_ansi_escape();
case 'F': // Cursor Previous Line
if (m_ansi_state.nums[0] == -1)
m_ansi_state.nums[0] = 1;
m_row = max<int32_t>(m_row - m_ansi_state.nums[0], 0);
m_column = 0;
return ResetAnsiEscape();
return reset_ansi_escape();
case 'G': // Cursor Horizontal Absolute
if (m_ansi_state.nums[0] == -1)
m_ansi_state.nums[0] = 1;
m_column = clamp<int32_t>(m_ansi_state.nums[0] - 1, 0, m_width - 1);
return ResetAnsiEscape();
return reset_ansi_escape();
case 'H': // Cursor Position
if (m_ansi_state.nums[0] == -1)
m_ansi_state.nums[0] = 1;
@@ -209,59 +209,59 @@ void TTY::HandleAnsiEscape(uint16_t ch)
m_ansi_state.nums[1] = 1;
m_row = clamp<int32_t>(m_ansi_state.nums[0] - 1, 0, m_height - 1);
m_column = clamp<int32_t>(m_ansi_state.nums[1] - 1, 0, m_width - 1);
return ResetAnsiEscape();
return reset_ansi_escape();
case 'J': // Erase in Display
dprintln("Unsupported ANSI CSI character J");
return ResetAnsiEscape();
return reset_ansi_escape();
case 'K': // Erase in Line
if (m_ansi_state.nums[0] == -1 || m_ansi_state.nums[0] == 0)
for (uint32_t i = m_column; i < m_width; i++)
PutCharAt(' ', i, m_row);
putchar_at(' ', i, m_row);
else
dprintln("Unsupported ANSI CSI character K");
return ResetAnsiEscape();
return reset_ansi_escape();
case 'S': // Scroll Up
dprintln("Unsupported ANSI CSI character S");
return ResetAnsiEscape();
return reset_ansi_escape();
case 'T': // Scroll Down
dprintln("Unsupported ANSI CSI character T");
return ResetAnsiEscape();
return reset_ansi_escape();
case 'f': // Horizontal Vertical Position
dprintln("Unsupported ANSI CSI character f");
return ResetAnsiEscape();
return reset_ansi_escape();
case 'm':
HandleAnsiSGR();
return ResetAnsiEscape();
handle_ansi_sgr();
return reset_ansi_escape();
default:
dprintln("Unsupported ANSI CSI character {}", ch);
return ResetAnsiEscape();
return reset_ansi_escape();
}
}
default:
dprintln("Unsupported ANSI mode");
return ResetAnsiEscape();
return reset_ansi_escape();
}
}
void TTY::RenderFromBuffer(uint32_t x, uint32_t y)
void TTY::render_from_buffer(uint32_t x, uint32_t y)
{
ASSERT(x < m_width && y < m_height);
const auto& cell = m_buffer[y * m_width + x];
m_terminal_driver->PutCharAt(cell.character, x, y, cell.foreground, cell.background);
m_terminal_driver->putchar_at(cell.character, x, y, cell.foreground, cell.background);
}
void TTY::PutCharAt(uint16_t ch, uint32_t x, uint32_t y)
void TTY::putchar_at(uint16_t ch, uint32_t x, uint32_t y)
{
ASSERT(x < m_width && y < m_height);
auto& cell = m_buffer[y * m_width + x];
cell.character = ch;
cell.foreground = m_foreground;
cell.background = m_background;
m_terminal_driver->PutCharAt(ch, x, y, m_foreground, m_background);
m_terminal_driver->putchar_at(ch, x, y, m_foreground, m_background);
}
void TTY::PutChar(char ch)
void TTY::putchar(char ch)
{
Kernel::LockGuard guard(m_lock);
@@ -271,8 +271,8 @@ void TTY::PutChar(char ch)
if (m_ansi_state.mode != 0)
{
HandleAnsiEscape(cp);
SetCursorPosition(m_column, m_row);
handle_ansi_escape(cp);
set_cursor_position(m_column, m_row);
return;
}
@@ -304,7 +304,7 @@ void TTY::PutChar(char ch)
m_ansi_state.mode = '\1';
break;
default:
PutCharAt(cp, m_column, m_row);
putchar_at(cp, m_column, m_row);
m_column++;
break;
}
@@ -326,37 +326,37 @@ void TTY::PutChar(char ch)
// Render the whole buffer to the screen
for (uint32_t y = 0; y < m_height; y++)
for (uint32_t x = 0; x < m_width; x++)
RenderFromBuffer(x, y);
render_from_buffer(x, y);
m_column = 0;
m_row--;
}
SetCursorPosition(m_column, m_row);
set_cursor_position(m_column, m_row);
}
void TTY::Write(const char* data, size_t size)
void TTY::write(const char* data, size_t size)
{
for (size_t i = 0; i < size; i++)
PutChar(data[i]);
putchar(data[i]);
}
void TTY::WriteString(const char* data)
void TTY::write_string(const char* data)
{
while (*data)
{
PutChar(*data);
putchar(*data);
data++;
}
}
void TTY::PutCharCurrent(char ch)
void TTY::putchar_current(char ch)
{
ASSERT(s_tty);
s_tty->PutChar(ch);
s_tty->putchar(ch);
}
bool TTY::IsInitialized()
bool TTY::is_initialized()
{
return s_tty != nullptr;
}

24
kernel/kernel/VesaTerminalDriver.cpp
View File

@@ -6,7 +6,7 @@
extern const struct bitmap_font font;
VesaTerminalDriver* VesaTerminalDriver::Create()
VesaTerminalDriver* VesaTerminalDriver::create()
{
if (!(g_multiboot_info->flags & MULTIBOOT_FLAGS_FRAMEBUFFER))
{
@@ -36,7 +36,7 @@ VesaTerminalDriver* VesaTerminalDriver::Create()
return nullptr;
}
MMU::Get().AllocateRange(framebuffer.addr, framebuffer.pitch * framebuffer.height);
MMU::get().allocate_range(framebuffer.addr, framebuffer.pitch * framebuffer.height);
auto* driver = new VesaTerminalDriver(
framebuffer.width,
@@ -46,18 +46,18 @@ VesaTerminalDriver* VesaTerminalDriver::Create()
framebuffer.addr,
font
);
driver->SetCursorPosition(0, 0);
driver->Clear(TerminalColor::BLACK);
driver->set_cursor_position(0, 0);
driver->clear(TerminalColor::BLACK);
return driver;
}
VesaTerminalDriver::~VesaTerminalDriver()
{
MMU::Get().UnAllocateRange(m_address, m_pitch * m_height);
MMU::get().unallocate_range(m_address, m_pitch * m_height);
}
void VesaTerminalDriver::SetPixel(uint32_t offset, Color color)
void VesaTerminalDriver::set_pixel(uint32_t offset, Color color)
{
uint32_t* pixel = (uint32_t*)(m_address + offset);
switch (m_bpp)
@@ -71,7 +71,7 @@ void VesaTerminalDriver::SetPixel(uint32_t offset, Color color)
}
}
void VesaTerminalDriver::PutCharAt(uint16_t ch, uint32_t x, uint32_t y, Color fg, Color bg)
void VesaTerminalDriver::putchar_at(uint16_t ch, uint32_t x, uint32_t y, Color fg, Color bg)
{
uint32_t glyph_index = 0;
for (uint32_t i = 0; i < m_font.Chars; i++)
@@ -95,14 +95,14 @@ void VesaTerminalDriver::PutCharAt(uint16_t ch, uint32_t x, uint32_t y, Color fg
for (uint32_t dx = 0; dx < m_font.Width && x + dx < m_width; dx++)
{
uint8_t bitmask = 1 << (font.Width - dx - 1);
SetPixel(pixel_offset, glyph[dy] & bitmask ? fg : bg);
set_pixel(pixel_offset, glyph[dy] & bitmask ? fg : bg);
pixel_offset += m_bpp / 8;
}
row_offset += m_pitch;
}
}
void VesaTerminalDriver::Clear(Color color)
void VesaTerminalDriver::clear(Color color)
{
if (m_bpp == 32)
{
@@ -119,14 +119,14 @@ void VesaTerminalDriver::Clear(Color color)
uint32_t pixel_offset = row_offset;
for (uint32_t x = 0; x < m_width; x++)
{
SetPixel(pixel_offset, color);
set_pixel(pixel_offset, color);
pixel_offset += m_bpp / 8;
}
row_offset += m_pitch;
}
}
void VesaTerminalDriver::SetCursorPosition(uint32_t x, uint32_t y)
void VesaTerminalDriver::set_cursor_position(uint32_t x, uint32_t y)
{
ASSERT(m_font.Height == 16 && m_font.Width == 8);
constexpr uint8_t cursor[] = {
@@ -159,7 +159,7 @@ void VesaTerminalDriver::SetCursorPosition(uint32_t x, uint32_t y)
{
uint8_t bitmask = 1 << (font.Width - dx - 1);
if (cursor[dy] & bitmask)
SetPixel(pixel_offset, s_cursor_color);
set_pixel(pixel_offset, s_cursor_color);
pixel_offset += m_bpp / 8;
}
row_offset += m_pitch;

12
kernel/kernel/kernel.cpp
View File

@@ -56,8 +56,6 @@ ParsedCommandLine ParseCommandLine()
return result;
}
static TTY* tty1 = nullptr;
extern "C" void kernel_main()
{
using namespace Kernel;
@@ -67,7 +65,7 @@ extern "C" void kernel_main()
auto cmdline = ParseCommandLine();
if (!cmdline.disable_serial)
Serial::Initialize();
Serial::initialize();
if (g_multiboot_magic != 0x2BADB002)
{
dprintln("Invalid multiboot magic number");
@@ -81,15 +79,15 @@ extern "C" void kernel_main()
IDT::initialize();
dprintln("IDT initialized");
MMU::Intialize();
MMU::intialize();
dprintln("MMU initialized");
TerminalDriver* terminal_driver = VesaTerminalDriver::Create();
TerminalDriver* terminal_driver = VesaTerminalDriver::create();
ASSERT(terminal_driver);
dprintln("VESA initialized");
tty1 = new TTY(terminal_driver);
TTY* tty1 = new TTY(terminal_driver);
InterruptController::Initialize(cmdline.force_pic);
InterruptController::initialize(cmdline.force_pic);
dprintln("Interrupt controller initialized");
PIT::initialize();

6
kernel/kernel/kmalloc.cpp
View File

@@ -55,10 +55,10 @@ static uintptr_t chunk_address(size_t index)
void kmalloc_initialize()
{
if (!(g_multiboot_info->flags & (1 << 6)))
Kernel::Panic("Kmalloc: Bootloader didn't provide a memory map");
Kernel::panic("Kmalloc: Bootloader didn't provide a memory map");
if ((uintptr_t)&g_kernel_end > s_kmalloc_base)
Kernel::Panic("Kmalloc: Kernel end ({}) is over kmalloc base ({})", &g_kernel_end, (void*)s_kmalloc_base);
Kernel::panic("Kmalloc: Kernel end ({}) is over kmalloc base ({})", &g_kernel_end, (void*)s_kmalloc_base);
// Validate kmalloc memory
bool valid = false;
@@ -81,7 +81,7 @@ void kmalloc_initialize()
if (!valid)
{
Kernel::Panic("Kmalloc: Could not find {}.{} MB of memory",
Kernel::panic("Kmalloc: Could not find {}.{} MB of memory",
(s_kmalloc_eternal_end - s_kmalloc_base) / MB,
(s_kmalloc_eternal_end - s_kmalloc_base) % MB
);