Luna/kernel/src/main.cpp

#include "ELF.h"
#include "InitRD.h"
#include "Log.h"
#include "arch/CPU.h"
#include "arch/MMU.h"
#include "arch/PCI.h"
#include "arch/Timer.h"
#include "boot/Init.h"
#include "config.h"
#include "fs/devices/DeviceRegistry.h"
#include "fs/tmpfs/FileSystem.h"
#include "memory/Heap.h"
#include "memory/KernelVM.h"
#include "memory/MemoryManager.h"
#include "thread/Scheduler.h"
#include "video/Framebuffer.h"
#include "video/TextConsole.h"
#include <luna/CString.h>
#include <luna/Result.h>
#include <luna/Units.h>

void reap_thread()
{
    while (true)
    {
        CPU::disable_interrupts();
        auto dying_threads = Scheduler::check_for_dying_threads();
        CPU::enable_interrupts();

        dying_threads.consume([](Thread* thread) { Scheduler::reap_thread(thread); });

        kernel_sleep(250);
    }
}

static void identify_processor()
{
    kinfoln("Current platform: %s", CPU::platform_string());

    kinfoln("Current processor: %s", CPU::identify().value_or("(unknown)"));
}

static void identify_memory()
{
    kinfoln("Total memory:    %s", to_dynamic_unit(MemoryManager::total()).release_value().chars());
    kinfoln("Free memory:     %s", to_dynamic_unit(MemoryManager::free()).release_value().chars());
    kinfoln("Used memory:     %s", to_dynamic_unit(MemoryManager::used()).release_value().chars());
    kinfoln("Reserved memory: %s", to_dynamic_unit(MemoryManager::reserved()).release_value().chars());
}

static Result<void> try_init_vfs()
{
    VFS::root_fs = TRY(TmpFS::FileSystem::create());

    TRY(DeviceRegistry::init());

    InitRD::populate_vfs();

    return {};
}

static void init_vfs()
{
    try_init_vfs().release_value();
}

static Result<void> try_init_userspace()
{
    auto init = TRY(VFS::resolve_path("/bin/init"));

    TRY(Scheduler::new_userspace_thread(init));

    return {};
}

static void init_userspace()
{
    try_init_userspace().release_value();
}

static void create_reaper()
{
    Scheduler::new_kernel_thread(reap_thread).release_value();
}

static void scan_pci()
{
    PCI::scan(
        [](const PCI::Device& device) {
            kinfoln("Found PCI mass storage device %.4x:%.4x, at address %u:%u:%u", device.id.vendor, device.id.device,
                    device.address.bus, device.address.slot, device.address.function);
        },
        { .klass = 1 });
}

static void transfer_control()
{
    // Disable console logging before transferring control to userspace.
    setup_log(log_debug_enabled(), log_serial_enabled(), false);

    CPU::enable_interrupts();
}

struct SplashAction
{
    const char* message;
    void (*action)(void);
};

constexpr SplashAction actions[] = {
    { "Identify Processor", identify_processor },  { "Initialize Timer", Timer::init },
    { "Identify System Memory", identify_memory }, { "Initialize Threads", Thread::init },
    { "Initialize Scheduler", Scheduler::init },   { "Initialize File System", init_vfs },
    { "Initialize Userspace", init_userspace },    { "Create Reaper Thread", create_reaper },
    { "Find Available Devices", scan_pci },        { "Final CPU Initialization", CPU::platform_finish_init },
    { "Start Userspace", transfer_control },
};

static constexpr u32 WHITE = 0xffffffff;
static constexpr u32 RED = 0xffff0000;
static constexpr u32 BLACK = 0xff000000;

static void update_splash(const char* message, u32 current, u32 total)
{
    const u32 line_height = Framebuffer::height() / 2;
    const u32 line_begin = 100;
    const u32 line_length = Framebuffer::width() - 200;

    if (current != total)
    {
        const u32 line_completed = (line_length / total) * current;

        Framebuffer::rect(line_begin, line_height, line_completed, 2, WHITE);
        Framebuffer::rect(line_begin + line_completed, line_height, line_length - line_completed, 2, RED);
    }
    else { Framebuffer::rect(line_begin, line_height, line_length, 2, WHITE); }

    Framebuffer::rect(line_begin, line_height + 20, line_length, 16, BLACK);

    TextConsole::move_to(Framebuffer::width() / 2 - 100, line_height + 20);
    TextConsole::printf("%s (%d%%)", message, (100 / total) * current).release_value();

    TextConsole::move_to(0, 0);

    for (int i = 0; i < 3000000; i++) CPU::pause();
}

Result<void> init()
{
    kinfoln("Starting Moon %s, built on %s at %s", MOON_VERSION, __DATE__, __TIME__);

    constexpr usize total_actions = sizeof(actions) / sizeof(actions[0]);

    for (usize i = 0; i < total_actions; i++)
    {
#ifndef DEBUG_MODE
        update_splash(actions[i].message, (u32)i, (u32)(total_actions - 1));
#else
        (void)update_splash;
#endif
        actions[i].action();
    }

    return {};
}

[[noreturn]] void init_wrapper()
{
    auto rc = init();
    if (rc.has_error()) kerrorln("Runtime error: %s", rc.error_string());
    CPU::idle_loop();
}

static constexpr u64 BOOTSTRAP_STACK_PAGES = 8;

// FIXME: Reclaim this memory as soon as we leave the init task (so as soon as the Scheduler runs a task switch)
static u64 allocate_initial_kernel_stack()
{
    u64 address = MemoryManager::alloc_for_kernel(BOOTSTRAP_STACK_PAGES + 1, MMU::ReadWrite | MMU::NoExecute).value();
    // First page is a guard page, the rest is stack.
    MMU::unmap(address); // Unmap (without deallocating VM) one guard page so that attempts to access it fail with a
                         // non-present page fault.
    kdbgln("stack guard page: %p", (void*)address);

    // The actual stack.
    Stack stack { address + ARCH_PAGE_SIZE, BOOTSTRAP_STACK_PAGES * ARCH_PAGE_SIZE };

    return stack.top();
}

extern "C" [[noreturn]] void _start()
{
    Init::check_magic();
    Init::early_init();
    u64 bootstrap_stack_top = allocate_initial_kernel_stack();
    CPU::bootstrap_switch_stack(bootstrap_stack_top, (void*)init_wrapper);
}