Boot::Handoff Class Reference

#include <Handoff.hpp>

Collaboration diagram for Boot::Handoff:

Public Member Functions
	Handoff ()
	Handoff (void *handoff, uint32_t magic)
const char *	CmdLine ()
const void *	Handle ()
Graphics::Framebuffer *	FramebufferInfo ()
HandoffBootloaderType *	BootType ()
Memory::MemoryMap *	MemoryMap ()

Static Private Member Functions
static void	parseStivale2 (Handoff *that, void *handoff)

Private Attributes
void *	m_handle
char *	m_cmdline
uint32_t	m_magic
Graphics::Framebuffer	m_framebuffer
HandoffBootloaderType	m_bootType
Memory::MemoryMap	m_memoryMap

Detailed Description

Definition at line 88 of file Handoff.hpp.

Constructor & Destructor Documentation

Handoff() [1/2]

Boot::Handoff::Handoff

(

)

Definition at line 38 of file Handoff.cpp.

    : m_handle(NULL)
    , m_magic(0)
{
    // Initialize nothing.
}

Handoff() [2/2]

Boot::Handoff::Handoff	(	void *	handoff,
		uint32_t	magic
	)

Definition at line 45 of file Handoff.cpp.

    : m_handle(handoff)
    , m_magic(magic)
{
    // Parse the handle based on the magic
    Logger::Info(__func__, "Bootloader info at 0x%p", handoff);
    if (magic == STIVALE2_MAGIC) {
        m_bootType = Stivale2;
        parseStivale2(this, handoff);
    } else {
        panic("Invalid bootloader magic!");
    }
}

Here is the call graph for this function:

Member Function Documentation

BootType()

HandoffBootloaderType* Boot::Handoff::BootType ( )

inline

Definition at line 97 of file Handoff.hpp.

{ return &m_bootType; }

CmdLine()

const char* Boot::Handoff::CmdLine ( )

inline

Definition at line 94 of file Handoff.hpp.

{ return m_cmdline; }

FramebufferInfo()

Graphics::Framebuffer* Boot::Handoff::FramebufferInfo ( )

inline

Definition at line 96 of file Handoff.hpp.

{ return &m_framebuffer; }

Handle()

const void* Boot::Handoff::Handle ( )

inline

Definition at line 95 of file Handoff.hpp.

{ return m_handle; }

MemoryMap()

Memory::MemoryMap* Boot::Handoff::MemoryMap ( )

inline

Definition at line 98 of file Handoff.hpp.

{ return &m_memoryMap; }

parseStivale2()

void Boot::Handoff::parseStivale2 ( Handoff *  that, void *  handoff  )

staticprivate

Definition at line 66 of file Handoff.cpp.

{
    Logger::Info(__func__, "Booted via Stivale2");
    // Walk the list of tags in the header
    struct stivale2_struct* fixed = (struct stivale2_struct*)handoff;
    struct stivale2_tag* tag = (struct stivale2_tag*)(fixed->tags);
    while (tag) {
        switch (tag->identifier) {
            case STIVALE2_STRUCT_TAG_MEMMAP_ID: {
                auto memmap = (struct stivale2_struct_tag_memmap*)tag;
                Logger::Debug(__func__, "Found %Lu Stivale2 memmap entries.", memmap->entries);
                if (memmap->entries > that->m_memoryMap.Count()) {
                    panic("Not enough space to add all memory map entries!");
                }
                // Follows the tag list order in stivale2.h
                for (size_t i = 0; i < memmap->entries; i++) {
                    auto entry = memmap->memmap[i];
                    uint64_t end = entry.base + entry.length - 1;
                    that->m_memoryMap[i] = Memory::Section(entry.base, end);
                    Logger::Debug(__func__, "[%zu] 0x%08LX-0x%08LX 0x%08LX", i, entry.base, end, entry.length);
                    // TODO: Make this a map that can be indexed
                    switch (entry.type) {
                        case STIVALE2_MMAP_USABLE:
                            that->m_memoryMap[i].setType(Memory::Available);
                            break;
 
                        case STIVALE2_MMAP_RESERVED:
                            that->m_memoryMap[i].setType(Memory::Reserved);
                            break;
 
                        case STIVALE2_MMAP_ACPI_RECLAIMABLE:
                            that->m_memoryMap[i].setType(Memory::ACPI);
                            break;
 
                        case STIVALE2_MMAP_ACPI_NVS:
                            that->m_memoryMap[i].setType(Memory::NVS);
                            break;
 
                        case STIVALE2_MMAP_BAD_MEMORY:
                            that->m_memoryMap[i].setType(Memory::Bad);
                            break;
 
                        case STIVALE2_MMAP_BOOTLOADER_RECLAIMABLE:
                            that->m_memoryMap[i].setType(Memory::Bootloader);
                            break;
 
                        case STIVALE2_MMAP_KERNEL_AND_MODULES:
                            that->m_memoryMap[i].setType(Memory::Kernel);
                            break;
 
                        default:
                            that->m_memoryMap[i].setType(Memory::Unknown);
                            break;
                    }
                }
                break;
            }
            case STIVALE2_STRUCT_TAG_CMDLINE_ID: {
                auto cmdline = (struct stivale2_struct_tag_cmdline*)tag;
                that->m_cmdline = (char*)(cmdline->cmdline);
                Logger::Debug(__func__, "Stivale2 cmdline: '%s'", that->m_cmdline);
                parseCommandLine(that->m_cmdline);
                break;
            }
            case STIVALE2_STRUCT_TAG_FRAMEBUFFER_ID: {
                auto framebuffer = (struct stivale2_struct_tag_framebuffer*)tag;
                Logger::Debug(
                    __func__,
                    "Stivale2 framebuffer:\n"
                    "\tAddress: 0x%08LX\n"
                    "\tResolution: %ux%ux%u\n"
                    "\tPixel format:\n"
                    "\t\tRed size:    %u\n"
                    "\t\tRed shift:   %u\n"
                    "\t\tGreen size:  %u\n"
                    "\t\tGreen shift: %u\n"
                    "\t\tBlue size:   %u\n"
                    "\t\tBlue shift:  %u",
                    framebuffer->framebuffer_addr,
                    framebuffer->framebuffer_width,
                    framebuffer->framebuffer_height,
                    framebuffer->framebuffer_bpp,
                    framebuffer->red_mask_size,
                    framebuffer->red_mask_shift,
                    framebuffer->green_mask_size,
                    framebuffer->green_mask_shift,
                    framebuffer->blue_mask_size,
                    framebuffer->blue_mask_shift);
                // Initialize the framebuffer information
                that->m_framebuffer = Graphics::Framebuffer(
                    framebuffer->framebuffer_width,
                    framebuffer->framebuffer_height,
                    framebuffer->framebuffer_bpp,
                    framebuffer->framebuffer_pitch,
                    reinterpret_cast<void*>(framebuffer->framebuffer_addr),
                    static_cast<Graphics::FramebufferMemoryModel>(framebuffer->memory_model),
                    framebuffer->red_mask_size,
                    framebuffer->red_mask_shift,
                    framebuffer->green_mask_size,
                    framebuffer->green_mask_shift,
                    framebuffer->blue_mask_size,
                    framebuffer->blue_mask_shift);
                break;
            }
            default: {
                Logger::Debug(__func__, "Unknown Stivale2 tag: 0x%016LX", tag->identifier);
                break;
            }
        }
 
        tag = (struct stivale2_tag*)tag->next;
    }
 
    Logger::Debug(__func__, "Done parsing Stivale2 tags");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Field Documentation

m_bootType

HandoffBootloaderType Boot::Handoff::m_bootType

private

Definition at line 107 of file Handoff.hpp.

m_cmdline

char* Boot::Handoff::m_cmdline

private

Definition at line 104 of file Handoff.hpp.

m_framebuffer

Graphics::Framebuffer Boot::Handoff::m_framebuffer

private

Definition at line 106 of file Handoff.hpp.

m_handle

void* Boot::Handoff::m_handle

private

Definition at line 103 of file Handoff.hpp.

m_magic

uint32_t Boot::Handoff::m_magic

private

Definition at line 105 of file Handoff.hpp.

m_memoryMap

Memory::MemoryMap Boot::Handoff::m_memoryMap

private

Definition at line 108 of file Handoff.hpp.

---

The documentation for this class was generated from the following files:

• Handoff.hpp
• Handoff.cpp