stivale2.c File Reference

#include <Arch/i686/Bootloader/EarlyPanic.hpp>
#include <Arch/i686/Bootloader/Loader.hpp>
#include <Arch/i686/Memory.i686.hpp>
#include <Arch/i686/regs.hpp>
#include <Support/sections.hpp>
#include <stdint.h>
#include <stivale/stivale2.h>

Include dependency graph for stivale2.c:

Go to the source code of this file.

Macros
#define	_STIVALE2_SPLIT_64
#define	KERNEL_STACK_SZ   4 * ARCH_PAGE_SIZE
#define	STIVALE2_MAGIC   0x73747632

Functions
	__attribute__ ((section(".early_bss"), aligned(4096)))
	__attribute__ ((section(".early_text")))
	__attribute__ ((section(".early_text"), noreturn))
	__attribute__ ((section(".early_data"), used)) const
	__attribute__ ((section(".stivale2hdr"), used)) const

Macro Definition Documentation

_STIVALE2_SPLIT_64

#define _STIVALE2_SPLIT_64

Definition at line 19 of file stivale2.c.

KERNEL_STACK_SZ

#define KERNEL_STACK_SZ   4 * ARCH_PAGE_SIZE

Definition at line 22 of file stivale2.c.

STIVALE2_MAGIC

#define STIVALE2_MAGIC   0x73747632

Definition at line 23 of file stivale2.c.

Function Documentation

__attribute__() [1/5]

__attribute__

(

(section(".early_bss"), aligned(4096))

)

Scan the stivale2 tags to find the reclaimable bootloader memory map tag that starts at the stivale2 tag base address. Return the length found. We'll memory map the entire area.

Definition at line 30 of file stivale2.c.

{
    while (tag) {
        switch (tag->identifier) {
            case STIVALE2_STRUCT_TAG_MEMMAP_ID:
            {
                struct stivale2_struct_tag_memmap* memmap = (struct stivale2_struct_tag_memmap*)tag;
                for (size_t i = 0; i < memmap->entries; i++) {
                    switch (memmap->memmap[i].type)
                    {
                        case STIVALE2_MMAP_BOOTLOADER_RECLAIMABLE:
                            if (((uint32_t)memmap->memmap[i].base) == (uint32_t)tag) {
                                return (uint32_t)memmap->memmap[i].length;
                            }
                            break;
 
                        default:
                            break;
                    }
                }
            }
            default:
                break;
        }
        tag = (struct stivale2_tag*)(uint32_t)tag->next;
    }
    // If we get here, there's a problem so we will panic and never return
    EarlyPanic("Error: Cannot detect bootloader info length!");
}

__attribute__() [2/5]

__attribute__

(

(section(".early_data"), used)

)

const

Definition at line 293 of file stivale2.c.

                                                                   {
    .tag = {
        .identifier = STIVALE2_HEADER_TAG_FRAMEBUFFER_ID,
        .next = 0,
    },
    .framebuffer_width  = 0,
    .framebuffer_height = 0,
    .framebuffer_bpp    = 0,
};

__attribute__() [3/5]

__attribute__

(

(section(".early_text"))

)

Finalize stage1 by loading the finalized page directory and enabling paging.

Stivale2 protocol kernel stage 1 entry. Stage 1 is responsible for providing an entry point for the bootloader in C, performing any necessary bootstrappign and then calling into the C++ stage 2.

identity map from 0x00000000 -> LOWMEM_END

Map kernel memory into the higher half of memory See linker.ld for details on where the kernel should be mapped.

Map bootloader information into the higher half of memory so that the kernel can access it and parse it.

Definition at line 113 of file stivale2.c.

{
    setPageDirectory((uintptr_t)&pageDirectory);
 
    struct CR0 cr0 = readCR0();
    cr0.pagingEnable = 1;
    writeCR0(cr0);
}

__attribute__() [4/5]

__attribute__

(

(section(".early_text"), noreturn)

)

Prepare a higher-half stack for kernel usage.

Definition at line 127 of file stivale2.c.

{
    // zero the kernel BSS (higher half stack)
    for (size_t i = 0; i < (size_t)&_BSS_SIZE; i++) {
        ((uint8_t*)&_BSS_START)[i] = 0;
    }
 
    // adjust the stack pointer to use the higher half, kernel stack
    asm volatile (
        "movl %0, %%esp\n"   // set the stack pointer
        "xor %%ebp, %%ebp\n" // clear the base pointer
        "pushl %1\n"         // push argument 2 (magic)
        "pushl %2\n"         // push argument 1 (info ptr)
        "pushl $0\n"         // push a null return address
        "jmp stage2Entry\n"  // jump to stage 2
        : // no output
        : "i" ((stage2Stack + sizeof(stage2Stack)))
        , "i" (STIVALE2_MAGIC)
        , "rm" (stivale2Info)
    );
 
    // it's impossible to return back to this function
    __builtin_unreachable();
}

__attribute__() [5/5]

__attribute__

(

(section(".stivale2hdr"), used)

)

const

Definition at line 304 of file stivale2.c.

                                           {
    .entry_point = (uint32_t)stage1Entry,
    .stack = (uint32_t)stage1Stack + sizeof(stage1Stack),
    .flags = 0,
    .tags = (uint32_t)&framebuffer_hdr_tag,
};