Luna/kernel/src/init/InitRD.cpp

#define MODULE "initrd"

#include "init/InitRD.h"
#include "bootboot.h"
#include "io/Serial.h"
#include "log/Log.h"
#include "memory/MemoryManager.h"
#include "misc/utils.h"
#include "std/stdlib.h"
#include <string.h>

extern BOOTBOOT bootboot;

static void* initrd_base;
static bool initrd_initialized = false;

bool InitRD::is_initialized()
{
    return initrd_initialized;
}

static inline int get_file_size_in_blocks(InitRD::File f)
{
    return f.size_in_blocks;
}

inline int InitRD::get_total_blocks()
{
    return bootboot.initrd_size / TAR_BLOCKSIZE;
}

inline InitRD::TarHeader* InitRD::get_block(int block_index)
{
    return (TarHeader*)((uintptr_t)initrd_base + block_index * TAR_BLOCKSIZE);
}

inline bool InitRD::is_valid_header(TarHeader* header)
{
    return strncmp(header->magic, TAR_MAGIC, 5) == 0;
}

uint64_t InitRD::get_file_physical_address(InitRD::File& file)
{
    return (uint64_t)file.addr - (uint64_t)initrd_base + (uint64_t)bootboot.initrd_ptr;
}

InitRD::File InitRD::get_file(TarHeader* header)
{
    File result;
    result.size = 0;
    memcpy(result.name, header->name, 100);
    int multiplier =
        1; // why they decided to store the size as an octal-encoded string instead of an integer is beyond me
    for (int i = 10; i >= 0; i--)
    {
        result.size += (multiplier * (header->size[i] - 48));
        multiplier *= 8;
    }
    result.addr = (void*)((uint64_t)header + TAR_BLOCKSIZE);
    result.size_in_blocks = Utilities::get_blocks_from_size(TAR_BLOCKSIZE, result.size);
    return result;
}

InitRD::File InitRD::open(const char* filename)
{
    int block = 0;
    int total_blocks = get_total_blocks();
    while (block < total_blocks)
    {
        TarHeader* hdr = (TarHeader*)get_block(block);
        if (hdr->typeflag == 53)
        {
            block++;
            continue;
        }
        if (!is_valid_header(hdr))
        {
            block++;
            continue;
        }
        auto f = get_file(hdr);
        if (strncmp(hdr->name, filename, strlen(filename)) == 0) { return f; }
        block += get_file_size_in_blocks(f) + 1;
    }
    File nullFile;
    nullFile.addr = NULL;
    nullFile.size = 0;
    memcpy(nullFile.name, "NULL", 5);
    return nullFile;
}

void InitRD::for_each(void (*callback)(File& f))
{
    int block = 0;
    int total_blocks = get_total_blocks();
    while (block < total_blocks)
    {
        TarHeader* hdr = (TarHeader*)get_block(block);
        if (hdr->typeflag == 53)
        {
            block++;
            continue;
        }
        if (!is_valid_header(hdr))
        {
            block++;
            continue;
        }
        auto f = get_file(hdr);
        block += get_file_size_in_blocks(f) + 1;
        callback(f);
    }
}

void InitRD::init()
{
    initrd_base = MemoryManager::get_unaligned_mappings((void*)bootboot.initrd_ptr, bootboot.initrd_size / 4096 + 1);
    kdbgln("physical base at %lx, size %lx, mapped to %lx", bootboot.initrd_ptr, bootboot.initrd_size,
           (uint64_t)initrd_base);
    initrd_initialized = true;
}