Parses and provides access to Multiboot 2 information. More...

#include <multiboot.h>

Public Member Functions
	Multiboot (unsigned long address, unsigned long magic)
	Constructor for the Multiboot class. Parses the multiboot info struct and loads the tags.

multiboot_tag_framebuffer *	framebuffer ()
	Get the framebuffer tag.

multiboot_tag_basic_meminfo *	basic_meminfo ()
	Get the basic memory info tag.

multiboot_tag_string *	bootloader_name ()
	Get the bootloader name tag.

multiboot_tag_mmap *	mmap ()
	Get the module tag.

multiboot_tag_old_acpi *	old_acpi ()
	Get the old ACPI tag.

multiboot_tag_new_acpi *	new_acpi ()
	Get the new ACPI tag.

multiboot_tag *	start_tag () const

bool	is_reserved (multiboot_uint64_t address) const
	Check if an address is reserved by a multiboot module.

Public Attributes
unsigned long	start_address
	The start address of the multiboot info struct.

unsigned long	end_address
	The end address of the multiboot info struct.

Detailed Description

Parses and provides access to Multiboot 2 information.

Definition at line 518 of file multiboot.h.

Constructor & Destructor Documentation

◆ Multiboot()

Multiboot::Multiboot	(	unsigned long	address,
		unsigned long	magic
	)

Constructor for the Multiboot class. Parses the multiboot info struct and loads the tags.

Parameters

address	The address of the multiboot info struct
magic	The magic number to confirm the bootloader

Definition at line 24 of file multiboot.cpp.

: start_address(address)
{
 
    // Confirm the bootloader
    ASSERT(magic == MULTIBOOT2_BOOTLOADER_MAGIC, "Multiboot2 Bootloader Not Detected");
    Logger::DEBUG() << "Multiboot2 Bootloader Detected at 0x" << (uint64_t) address << "\n";
 
    multiboot_tag* tag = start_tag();
 
    // Loop through the tags and load them
    while (true) {
 
        // Handle the tag
        switch (tag->type) {
 
            case MULTIBOOT_TAG_TYPE_END:
                end_address = (unsigned long) PhysicalMemoryManager::to_lower_region((uint64_t) tag);
                return;
 
            case MULTIBOOT_TAG_TYPE_FRAMEBUFFER:
                m_framebuffer = (multiboot_tag_framebuffer*) tag;
                break;
 
            case MULTIBOOT_TAG_TYPE_BASIC_MEMINFO:
                m_basic_meminfo = (multiboot_tag_basic_meminfo*) tag;
                break;
 
            case MULTIBOOT_TAG_TYPE_BOOT_LOADER_NAME:
                m_bootloader_name = (multiboot_tag_string*) tag;
                Logger::DEBUG() << "Bootloader: " << m_bootloader_name->string << "\n";
                break;
 
            case MULTIBOOT_TAG_TYPE_BOOTDEV:
                multiboot_tag_bootdev* bootdev;
                bootdev = (multiboot_tag_bootdev*) tag;
                Logger::DEBUG() << "Boot device: drive=0x" << (uint64_t) bootdev->biosdev << ", partition=0x" << (uint64_t) bootdev->part << "\n";
                break;
 
            case MULTIBOOT_TAG_TYPE_MMAP:
 
                // If there is not already a mmap tag, set it
                if (m_mmap == nullptr)
                    m_mmap = (multiboot_tag_mmap*) tag;
 
                break;
 
            case MULTIBOOT_TAG_TYPE_ACPI_OLD:
                m_old_acpi = (multiboot_tag_old_acpi*) tag;
                break;
 
 
            case MULTIBOOT_TAG_TYPE_ACPI_NEW:
                m_new_acpi = (multiboot_tag_new_acpi*) tag;
                break;
 
            case MULTIBOOT_TAG_TYPE_MODULE:
                multiboot_tag_module* module;
                module = (multiboot_tag_module*) tag;
                Logger::DEBUG() << "Module: start=0x" << (uint64_t) module->mod_start << ", end=0x" << (uint64_t) module->mod_end << ", cmdline=" << module->cmdline << "\n";
                m_module = module;
                break;
        }
 
        // Move to the next tag
        tag = (struct multiboot_tag*) ((multiboot_uint8_t*) tag + ((tag->size + 7) & ~7));
    }
}

References ASSERT, MaxOS::Logger::DEBUG(), end_address, start_tag(), multiboot_tag_string::string, and MaxOS::memory::PhysicalMemoryManager::to_lower_region().

Member Function Documentation

◆ basic_meminfo()

multiboot_tag_basic_meminfo * Multiboot::basic_meminfo ( )

Get the basic memory info tag.

Returns: The basic memory info tag

Definition at line 108 of file multiboot.cpp.

                                                      {
 
    return m_basic_meminfo;
}

◆ bootloader_name()

multiboot_tag_string * Multiboot::bootloader_name ( )

Get the bootloader name tag.

Returns: The bootloader name tag

Definition at line 117 of file multiboot.cpp.

                                                 {
 
    return m_bootloader_name;
}

◆ framebuffer()

multiboot_tag_framebuffer * Multiboot::framebuffer ( )

Get the framebuffer tag.

Returns: The framebuffer tag

Definition at line 99 of file multiboot.cpp.

                                                  {
 
    return m_framebuffer;
}

◆ is_reserved()

bool Multiboot::is_reserved ( multiboot_uint64_t address ) const

Check if an address is reserved by a multiboot module.

Parameters

address The address to check

Returns: True if the address is reserved

Definition at line 154 of file multiboot.cpp.

                                                            {
 
    // Loop through the tags checking if the address is reserved
    for (multiboot_tag* tag = start_tag(); tag->type != MULTIBOOT_TAG_TYPE_END; tag = (struct multiboot_tag*) ((multiboot_uint8_t*) tag + ((tag->size + 7) & ~7))) {
 
        // Check if the tag is a module or mmap
        if (tag->type != MULTIBOOT_TAG_TYPE_MODULE && tag->type != MULTIBOOT_TAG_TYPE_MMAP)
            continue;
 
        // Get the module tag
        auto* module = (struct multiboot_tag_module*) tag;
 
        // Check if the address is within the module
        if (address >= module->mod_start && address < module->mod_end)
            return true;
    }
 
 
    // Not part of multiboot
    return false;
 
}

References start_tag().

◆ mmap()

multiboot_tag_mmap * Multiboot::mmap ( )

Get the module tag.

Returns: The module tag

Definition at line 126 of file multiboot.cpp.

                                    {
 
    return m_mmap;
}

Referenced by MaxOS::memory::PhysicalMemoryManager::PhysicalMemoryManager().

◆ new_acpi()

multiboot_tag_new_acpi * Multiboot::new_acpi ( )

Get the new ACPI tag.

Returns: The new ACPI tag

Definition at line 144 of file multiboot.cpp.

                                            {
 
    return m_new_acpi;
}

◆ old_acpi()

multiboot_tag_old_acpi * Multiboot::old_acpi ( )

Get the old ACPI tag.

Returns: The old ACPI tag

Definition at line 135 of file multiboot.cpp.

                                            {
 
    return m_old_acpi;
}

◆ start_tag()

multiboot_tag * Multiboot::start_tag ( ) const

Get the start tag of the multiboot information (useful for iterating through the tags)

Returns: The start tag

Definition at line 182 of file multiboot.cpp.

                                          {
 
    return (multiboot_tag*) (start_address + HIGHER_HALF_KERNEL_OFFSET + 8);
}

References MaxOS::memory::HIGHER_HALF_KERNEL_OFFSET, and start_address.

Referenced by is_reserved(), MaxOS::processes::GlobalScheduler::load_multiboot_elfs(), and Multiboot().

Member Data Documentation

◆ end_address

unsigned long MaxOS::system::Multiboot::end_address

The end address of the multiboot info struct.

Definition at line 540 of file multiboot.h.

Referenced by Multiboot().

◆ start_address

unsigned long MaxOS::system::Multiboot::start_address

The start address of the multiboot info struct.

Definition at line 539 of file multiboot.h.

Referenced by start_tag().

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

/home/runner/work/MaxOS/MaxOS/kernel/include/system/multiboot.h
/home/runner/work/MaxOS/MaxOS/kernel/src/system/multiboot.cpp

Public Member Functions

Public Attributes