main.c

Go to the documentation of this file.

//main.c - main kernel codebase
#include "../usr/shell.h" //shell
#include "../io/vga.h" //vga functions
#include "../io/cm.h" //for init
#include "../lib/utils.h" //for general purpose
#include "../mem/heap.h" //for init and for malloc wrapper when using gdb, comment the function if not debugging or having issues with allocation
//use alc for writing native code
#include "../fs/ide.h" //for init
#include "../fs/ffs.h" //for init
#include "../fs/fs.h" //for init
#include "../lib/err.h" //for init
#include "../io/io.h" //for init
#include "../lib/pit.h" //for delay and init
#include "../mem/mem.h" //mem functions
 
#define KHEAP_SIZE (1024 * 1024) //1mb main heap
#define FS_ARENA_SIZE (256 * 1024) //256kb for filesystem
#define CMD_ARENA_SIZE (128 * 1024) //128kb for shell commands
 
void ___init(void); //prototypes
void* malloc(uint32_t size);
NORETURN void ___kmain(uint32_t magic, void *mb_info);
 
/**
 * @brief description of heap sizes in src/kernel/main.c
 * 
 * there are 3 heaps in the kernel, kheap (kernel heap)
 * with childs of fs_arena (filesystem arena) and cmd_arena (command arena)
 * kheap is 1mb total
 * fs_arena is 256kb from kheap
 * cmd_arena is 128kb from kheap
 *
 * this leaves 640kb~ of space in kheap
 * 
 * @see hinit(), anew(), res(), and alc()
*/
/**
 * @brief the main kernel heap
 *
 * kheap is the primary 1mb arena that all kernel allocations
 * come from, child arenas are carved out of this heap
 *
 * @see fs_arena, cmd_arena, hinit(), alc()
 */
static uint8_t kmem[KHEAP_SIZE];
arena_t kheap;
 
/**
 * @brief the filesystem child arena
 *
 * fs_arena is a 256kb arena allocated from kheap and used for
 * filesystem operations like storing filenames and file data
 *
 * @see kheap, cmd_arena, anew()
 */
arena_t *fs_arena;
 
/**
 * @brief the command processing child arena
 *
 * cmd_arena is a 128kb arena allocated from kheap and reset
 * before each shell command to provide temporary scratch space
 *
 * @see kheap, fs_arena, res()
 */
arena_t *cmd_arena;
 
static int ___init_called = 0;
 
/**
 * @brief ___init initializes all kernel subsystems
 *
 * ___init is a function that sets up the kernel heap, child arenas,
 * pit timer, ide disk controller, flat filesystem, and filesystem
 * tooling, then runs a full sanity check suite before returning
 *
 * ___init is called once at boot time and will panic if called twice
 *
 * using ___init is done with
 * @code{.c}
 * ___init();
 * @endcode
 *
 * @see kmain(), hinit(), ideinit(), fsinit()
 */
void ___init(void) {
    if (___init_called) {
        panic("init: called twice");
    }
    //ensure init is guarded
    ___init_called = 1;
    
    hcur();
    clscr();
    int row = 0;
 
    //main heap initialization (1mb)
    hinit(&kheap, kmem, sizeof(kmem));
    //sanity check: try a small allocation
    void *test = alc(&kheap, 16);
    assert(test != NULL, "init: heap allocation failed");
    assert((uint32_t)test >= (uint32_t)kmem, "init: heap returned address outside bounds");
    prt(0, row++, "[ OK ] main heap (1mb)", 0x0A);
    
    //create filesystem arena (256kb from main heap)
    fs_arena = anew(&kheap, FS_ARENA_SIZE);
    assert(fs_arena != NULL, "init: failed to create fs arena");
    prt(0, row++, "[ OK ] fs arena (256kb)", 0x0A);
    
    //create command arena (128kb from main heap)
    cmd_arena = anew(&kheap, CMD_ARENA_SIZE);
    assert(cmd_arena != NULL, "init: failed to create command arena");
    prt(0, row++, "[ OK ] cmd arena (128kb)", 0x0A);
    
    //pit initialization
    pinit();
    prt(0, row++, "[ OK ] pit timer", 0x0A);
    
    //ide initialization
    ideinit();
    //sanity check: try reading disk signature
    uint8_t test_sector[512];
    irsec(0, test_sector);  //irsec returns void, just call it
    //check if sector has any data (non-zero)
    int empty = 1;
    for (int i = 0; i < 512; i++) {
        if (test_sector[i] != 0) {
            empty = 0;
            break;
        }
    }
    if (empty) {
        prt(0, row++, "[WARN] ide - sector 0 all zeros, disk may be empty", 0x06);
    } else {
        prt(0, row++, "[ OK ] ide ", 0x0A);
    }
    
    //ffs initialization
    ffsinit();
    //sanity check: verify filesystem signature
    uint8_t magic[512];
    irsec(1, magic);
    if (magic[0] == 'F' && magic[1] == 'S') {
        prt(0, row++, "[ OK ] ffs", 0x0A);
    } else {
        prt(0, row++, "[WARN] ffs - no valid filesystem, will create new one", 0x06);
    }
    
    //fs initialization
    fsinit(fs_arena);
    //sanity check: verify we can read file count
    int check_lba = (int)fsfind(""); //will return 0 if nothing exists
    if (check_lba == 0) {
        prt(0, row++, "[ OK ] fs (empty)", 0x0A);
    } else {
        prt(0, row++, "[ OK ] fs", 0x0A);
    }
        
    //final sanity check suite - init doesnt complete until everything proves it works    
    int sanity_passed = 1;
    
    //heap test - allocate, write, read, verify
    void *htest = alc(&kheap, 64);
    assert(htest != NULL, "sanity: heap allocation failed");
    uint8_t *hbytes = (uint8_t*)htest;
    for (int i = 0; i < 64; i++) {
        hbytes[i] = (uint8_t)(i & 0xFF);
    }
    for (int i = 0; i < 64; i++) {
        if (hbytes[i] != (i & 0xFF)) {
            panic("sanity: heap memory corruption");
        }
    }
    prt(0, row++, "[ OK ] heap read/write", 0x0A);
       
    //disk test - write a test sector, read it back, verify
    uint8_t wsector[512];
    uint8_t rsector[512];
    for (int i = 0; i < 512; i++) wsector[i] = (uint8_t)(i & 0xFF);
    uint32_t tlba = 200; //use lba far from filesystem area
    iwrt(tlba, wsector);
    irsec(tlba, rsector);
    for (int i = 0; i < 512; i++) {
        if (rsector[i] != (i & 0xFF)) {
            panic("sanity: disk write/read mismatch");
        }
    }
    prt(0, row++, "[ OK ] disk write/read", 0x0A);
    
    //fs test - create, write, read, delete
    const char *tname = ".sanity_test";
    const char *tcontent = "this is a sanity check file if you can read this, the fs works.";
    fswrite(fs_arena, tname, tcontent);
    char *rback = fsread(tname);
    assert(rback != NULL, "sanity: fsread returned NULL");
    if (strcmp(tcontent, rback) != 0) {
        panic("sanity: file content mismatch");
    }
    fsdelete(tname);
    uint32_t dlba = fsfind(tname);
    assert(dlba == 0, "sanity: file still exists after delete");
    prt(0, row++, "[ OK ] filesystem operations", 0x0A);
 
    //interrupt test verify keyboard controller responds
    uint8_t kbtest = inb(0x64); //read controller status
    if ((kbtest & 0x01) == 0) {
    //keyboard buffer empty still okay - controller alive
    prt(0, row++, "[ OK ] keyboard controller", 0x0A);
    } else {
    prt(0, row++, "[ OK ] keyboard controller", 0x0A); //still passes, just has data
    }
 
    //cursor test
    //just verify cursor movement works
    int tcx, tcy;
    scur();
    cob(10, 10);
    cnb(&tcx, &tcy);
    hcur();
    if (tcx != 10 || tcy != 10) {
        panic("sanity: cursor positioning failed");
    }
    prt(0, row++, "[ OK ] cursor positioning", 0x0A);
 
    //all checks passed
    if (sanity_passed) {
       //do none
    }
   
    scur();
    
    int crow = row + 2; //we need row = row + 2 but that causes issues, better solution is to use a cursor row
    cob(0, crow);
    prt(0, row++, "[ OK ] init complete", 0x0A);
}
 
/**
 * @brief malloc is a gdb friendly wrapper around alc
 *
 * malloc is a function that allocates memory from the main kernel
 * heap, it exists primarily for gdb compatibility
 * @param size, the number of bytes to allocate
 *
 * @warning when writing kernel code, use alc directly instead of
 * malloc, since malloc is only a thin wrapper for debugging
 *
 * @see alc(), kheap
 */
void* malloc(uint32_t size) {
    return alc(&kheap, size); //use alc in actual kernel code, DO NOT use malloc
}
 
/**
 * @brief ___kmain is the main kernel entry point after boot
 *
 * ___kmain is a function called by the multiboot bootloader that
 * verifies the multiboot magic, runs kernel initialization, and
 * enters the infinite interactive shell loop
 * @param magic, the multiboot magic number (should be 0x2BADB002)
 * @param mb_info, a pointer to the multiboot information structure
 *
 * using ___kmain is done with
 * @code{.c}
 * //called from boot.s with multiboot info:
 * ___kmain(0x2BADB002, multiboot_info_ptr);
 * @endcode
 *
 * @see ___init(), boot.s, shell()
 */
NORETURN void ___kmain(uint32_t magic, void *mb_info) {
    //verify magic num
    if (magic != 0x2BADB002) panic("kmain: invalid multiboot magic");
    
    ___init(); //init system
 
    while(1) {
        shell(mb_info);
    }
}