mbentry.c File Reference

#include <stdbool.h>
#include <stdint.h>
#include <sys/kassert.h>
#include <sys/cdefs.h>
#include "../dev/console.h"
#include <machine/amd64.h>
#include <machine/pmap.h>
#include <machine/multiboot.h>

Include dependency graph for mbentry.c:

Go to the source code of this file.

Macros
#define	CHECK_FLAG(flag, bit)   ((flag) & (1 << (bit)))
#define	PAGE_ALIGN   __attribute__((aligned(PGSIZE)))
#define	DATA_SECTION   __attribute__((section(".data")))
#define	MAX_REGIONS   16

Functions
void	MachineBoot_Entry (unsigned long magic, unsigned long addr)
void	Machine_EarlyInit ()
void	Machine_Init ()
void	PAlloc_AddRegion (uintptr_t start, uintptr_t len)
void	MachineBoot_AddMem ()

Variables
PAGE_ALIGN DATA_SECTION PageTable	bootpgtbl3
PAGE_ALIGN DATA_SECTION PageTable	bootpgtbl2
PAGE_ALIGN DATA_SECTION PageTable	bootpgtbl1
static uintptr_t	memRegionStart [MAX_REGIONS]
static uintptr_t	memRegionLen [MAX_REGIONS]
static int	memRegionIdx

Macro Definition Documentation

CHECK_FLAG

#define CHECK_FLAG	(		flag,
			bit
	)		((flag) & (1 << (bit)))

Definition at line 19 of file mbentry.c.

DATA_SECTION

#define DATA_SECTION   __attribute__((section(".data")))

Definition at line 22 of file mbentry.c.

MAX_REGIONS

#define MAX_REGIONS   16

Definition at line 74 of file mbentry.c.

PAGE_ALIGN

#define PAGE_ALIGN   __attribute__((aligned(PGSIZE)))

Definition at line 21 of file mbentry.c.

Function Documentation

Machine_EarlyInit()

void Machine_EarlyInit

(

)

Machine_EarlyInit –

Initializes early kernel state.

Definition at line 146 of file machine.c.

{
    Spinlock_EarlyInit();
    Critical_Init();
    Critical_Enter();
    WaitChannel_EarlyInit();
    Console_Init();
    PAlloc_Init();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Machine_Init()

void Machine_Init

(

)

Machine_Init –

At this point the assembly startup code has setup temporary processor data structures sufficient to execute C code and make it through this initialization routine.

Definition at line 169 of file machine.c.

{
    /*
     * Initialize Processor State
     */
    Machine_GDTInit();
    Machine_TSSInit();
    Trap_Init();
    Machine_SyscallInit();
    clts(); // Enable FPU/XMM
 
    /*
     * Initialize Memory Allocation and Virtual Memory
     */
    PAlloc_AddRegion(DMPA2VA(16*1024*1024), 16*1024*1024);
    PMap_Init();
    XMem_Init();
    PAlloc_LateInit();
    MachineBoot_AddMem();
 
    /*
     * Initialize Time Keeping
     */
    KTime_Init();
    RTC_Init(); // Finishes initializing KTime
 
    /*
     * Initialize Interrupts
     */
    IRQ_Init();
    LAPIC_Init();
    IOAPIC_Init();
    IOAPIC_Enable(0); // Enable timer interrupts
    Thread_Init();
 
    KTimer_Init(); // Depends on RTC and KTime
 
    /*
     * Initialize Additional Processors
     */
    MP_Init();
 
    /*
     * Initialize Basic Devices
     */
    PS2_Init(); // PS2 Keyboard
    PCI_Init(); // PCI BUS
    IDE_Init(); // IDE Disk Controller
    BufCache_Init();
 
    /*
     * Open the primary disk and mount the root file system
     */
    Disk *root = Disk_GetByID(0, 0);
    if (!root)
        Panic("No boot disk!");
    VFS_MountRoot(root);
 
    Critical_Exit();
 
    /*
     * Create the idle thread
     */
    Thread *thr = Thread_KThreadCreate(&Machine_IdleThread, NULL);
    if (thr == NULL) {
        kprintf("Couldn't create idle thread!\n");
    }
    Sched_SetRunnable(thr);
 
    /*
     * Load the init processor
     */
    Loader_LoadInit();
 
    breakpoint();
}

Here is the call graph for this function:

Here is the caller graph for this function:

MachineBoot_AddMem()

void MachineBoot_AddMem

(

)

Definition at line 192 of file mbentry.c.

{
    int i;
    uintptr_t initRamEnd = 32*1024*1024;
 
    for (i = 0; i < memRegionIdx; i++)
    {
        uintptr_t start = memRegionStart[i];
        uintptr_t len = memRegionLen[i];
 
        if (start + len < initRamEnd)
            continue;
 
        if (start < initRamEnd) {
            len = initRamEnd - start;
            start = initRamEnd;
        }
 
        kprintf("AddRegion: %08llx %08llx\n", start, len);
        PAlloc_AddRegion(start + MEM_DIRECTMAP_BASE, len);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

MachineBoot_Entry()

void MachineBoot_Entry	(	unsigned long	magic,
		unsigned long	addr
	)

Definition at line 81 of file mbentry.c.

{
    multiboot_info_t *mbi = (multiboot_info_t *)addr;
 
    Machine_EarlyInit();
 
    /* @r{Am I booted by a Multiboot-compliant boot loader?} */
    if (magic != MULTIBOOT_BOOTLOADER_MAGIC)
    {
      kprintf("Invalid magic number: 0x%x\n", magic);
      //return;
    }
 
    /* @r{Print out the flags.} */
    kprintf("flags = 0x%x\n", (uint64_t) mbi->flags);
 
    /* @r{Are mem_* valid?} */
    if (CHECK_FLAG (mbi->flags, 0))
        kprintf("mem_lower = %uKB, mem_upper = %uKB\n",
                (unsigned) mbi->mem_lower, (unsigned) mbi->mem_upper);
 
    /* @r{Is boot_device valid?} */
    if (CHECK_FLAG (mbi->flags, 1))
        kprintf("boot_device = 0x%x\n", (unsigned) mbi->boot_device);
  
    /* @r{Is the command line passed?} */
    if (CHECK_FLAG (mbi->flags, 2))
        kprintf("cmdline = %s\n", (char *)(uintptr_t)mbi->cmdline);
 
    /* @r{Are mods_* valid?} */
    if (CHECK_FLAG (mbi->flags, 3))
    {
        multiboot_module_t *mod;
        int i;
      
        kprintf("mods_count = %d, mods_addr = 0x%x\n",
                (int) mbi->mods_count, (int) mbi->mods_addr);
        for (i = 0, mod = (multiboot_module_t *)(uintptr_t)mbi->mods_addr;
             i < mbi->mods_count;
             i++, mod++)
            kprintf(" mod_start = 0x%x, mod_end = 0x%x, cmdline = %s\n",
                    (unsigned) mod->mod_start,
                    (unsigned) mod->mod_end,
                    (char *)(uintptr_t) mod->cmdline);
    }
 
    /* @r{Bits 4 and 5 are mutually exclusive!} */
    if (CHECK_FLAG (mbi->flags, 4) && CHECK_FLAG (mbi->flags, 5))
    {
        kprintf("Both bits 4 and 5 are set.\n");
        return;
    }
 
    /* @r{Is the symbol table of a.out valid?} */
    if (CHECK_FLAG (mbi->flags, 4))
    {
        multiboot_aout_symbol_table_t *multiboot_aout_sym = &(mbi->u.aout_sym);
      
        kprintf("multiboot_aout_symbol_table: tabsize = 0x%0x\n"
                "                             strsize = 0x%x, addr = 0x%x\n",
                (unsigned) multiboot_aout_sym->tabsize,
                (unsigned) multiboot_aout_sym->strsize,
                (unsigned) multiboot_aout_sym->addr);
    }
 
    /* @r{Is the section header table of ELF valid?} */
    if (CHECK_FLAG (mbi->flags, 5))
    {
        multiboot_elf_section_header_table_t *multiboot_elf_sec = &(mbi->u.elf_sec);
 
        kprintf("multiboot_elf_sec: num = %u, size = 0x%x,"
                " addr = 0x%x, shndx = 0x%x\n",
                (unsigned) multiboot_elf_sec->num, (unsigned) multiboot_elf_sec->size,
                (unsigned) multiboot_elf_sec->addr, (unsigned) multiboot_elf_sec->shndx);
    }
 
    memRegionIdx = 0;
 
    /* @r{Are mmap_* valid?} */
    if (CHECK_FLAG (mbi->flags, 6))
    {
        multiboot_memory_map_t *mmap;
 
        kprintf("mmap_addr = 0x%x, mmap_length = 0x%x\n",
                (unsigned) mbi->mmap_addr, (unsigned) mbi->mmap_length);
        for (mmap = (multiboot_memory_map_t *)(uintptr_t) mbi->mmap_addr;
            (unsigned long) mmap < mbi->mmap_addr + mbi->mmap_length;
            mmap = (multiboot_memory_map_t *) ((unsigned long) mmap
                                    + mmap->size + sizeof (mmap->size)))
        {
            kprintf(" size = 0x%x, base_addr = 0x%llx,"
                    " length = 0x%llx, type = 0x%x\n",
                    (unsigned) mmap->size,
                    mmap->addr,
                    mmap->len,
                    (unsigned) mmap->type);
            if (mmap->type == MULTIBOOT_MEMORY_AVAILABLE) {
                memRegionStart[memRegionIdx] = mmap->addr;
                memRegionLen[memRegionIdx] = mmap->len;
                memRegionIdx++;
            }
        }
    }
 
    // Main initialization
    Machine_Init();
 
    return;
}

Here is the call graph for this function:

PAlloc_AddRegion()

void PAlloc_AddRegion	(	uintptr_t	start,
		uintptr_t	len
	)

PAlloc_AddRegion –

Add a physical memory region to the page allocator.

Definition at line 92 of file palloc.c.

{
    uintptr_t i;
    FreePage *pg;
 
    if ((start % PGSIZE) != 0)
        Panic("Region start is not page aligned!");
    if ((len % PGSIZE) != 0)
        Panic("Region length is not page aligned!");
 
    /*
     * PageInfo table isn't initialized on the first call to this function.  We 
     * must allocate a temporary table that will be copied into the XMem region 
     * inside PAlloc_LateInit.
     *
     * Note that the PageInfo table is invalid for regions that are not added 
     * to the free list such as MMIO regions.
     */
    if (pageInfoTable == NULL) {
        // Physical Address Offsets
        uintptr_t base = (uintptr_t)DMVA2PA(start);
        uintptr_t end = base + len;
 
        pageInfoLength = ROUNDUP(end / PGSIZE * sizeof(PageInfo), PGSIZE);
        pageInfoTable = (PageInfo *)start;
 
        start += pageInfoLength;
        len -= pageInfoLength;
 
        for (i = 0; i < (base / PGSIZE); i++) {
            pageInfoTable[i].refCount = 1;
        }
        for (i = (base / PGSIZE); i < (end / PGSIZE); i++) {
            pageInfoTable[i].refCount = 0;
        }
        for (i = 0; i < (pageInfoLength / PGSIZE); i++) {
            pageInfoTable[i + (base / PGSIZE)].refCount = 1;
        }
    } else {
        /*
         * Only the first call to AddRegion should occur before the XMem region 
         * is initialized.
         */
        
        ASSERT(pageInfoXMem != NULL);
 
        uintptr_t base = (uintptr_t)DMVA2PA(start);
        uintptr_t end = base + len;
 
        uintptr_t newLength = ROUNDUP(end / PGSIZE * sizeof(PageInfo), PGSIZE);
 
        if (!XMem_Allocate(pageInfoXMem, newLength))
            Panic("Cannot allocate XMem region!");
 
        // Initialize new pages
        for (i = (base / PGSIZE); i < (end / PGSIZE); i++) {
            pageInfoTable[i].refCount = 0;
        }
    }
 
    Spinlock_Lock(&pallocLock);
    for (i = 0; i < len; i += PGSIZE)
    {
        pg = (void *)(start + i);
        pg->magic = FREEPAGE_MAGIC_FREE;
 
        totalPages++;
        freePages++;
 
        LIST_INSERT_HEAD(&freeList, pg, entries);
    }
    Spinlock_Unlock(&pallocLock);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

bootpgtbl1

PAGE_ALIGN DATA_SECTION PageTable bootpgtbl1

Initial value:

= { .entries = {
    ((uint64_t)&bootpgtbl2 - MEM_DIRECTMAP_BASE) + 0x03,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    [256] = ((uint64_t)&bootpgtbl2 - MEM_DIRECTMAP_BASE) + 0x03,
}}

Definition at line 53 of file mbentry.c.

bootpgtbl2

PAGE_ALIGN DATA_SECTION PageTable bootpgtbl2

Initial value:

= { .entries = {
    ((uint64_t)&bootpgtbl3 - MEM_DIRECTMAP_BASE) + 0x03,
    0
}}

Definition at line 48 of file mbentry.c.

bootpgtbl3

PAGE_ALIGN DATA_SECTION PageTable bootpgtbl3

Initial value:

= { .entries = {
    0x0000000000000183,
    0x0000000000200183,
    0x0000000000400183,
    0x0000000000600183,
    0x0000000000800183,
    0x0000000000A00183,
    0x0000000000C00183,
    0x0000000000E00183,
    0x0000000001000183,
    0x0000000001200183,
    0x0000000001400183,
    0x0000000001600183,
    0x0000000001800183,
    0x0000000001A00183,
    0x0000000001C00183,
    0x0000000001E00183,
    0x0000000002000183,
}}

Definition at line 28 of file mbentry.c.

memRegionIdx

int memRegionIdx

static

Definition at line 78 of file mbentry.c.

memRegionLen

uintptr_t memRegionLen[MAX_REGIONS]

static

Definition at line 77 of file mbentry.c.

memRegionStart

uintptr_t memRegionStart[MAX_REGIONS]

static

Definition at line 76 of file mbentry.c.