machine.c File Reference

#include <stdbool.h>
#include <stdint.h>
#include <sys/kconfig.h>
#include <sys/kassert.h>
#include <sys/kmem.h>
#include <sys/mp.h>
#include <sys/irq.h>
#include <sys/spinlock.h>
#include <machine/amd64.h>
#include <machine/ioapic.h>
#include <machine/lapic.h>
#include <machine/trap.h>
#include <machine/pmap.h>
#include <machine/mp.h>
#include <sys/thread.h>
#include <sys/disk.h>
#include <sys/bufcache.h>
#include <sys/vfs.h>
#include <sys/elf64.h>
#include "../dev/console.h"

Include dependency graph for machine.c:

Go to the source code of this file.

Macros
#define	GDT_MAX   8

Functions
void	KTime_Init ()
void	KTimer_Init ()
void	RTC_Init ()
void	PS2_Init ()
void	PCI_Init ()
void	IDE_Init ()
void	MachineBoot_AddMem ()
void	Loader_LoadInit ()
void	PAlloc_LateInit ()
static void	Machine_GDTInit ()
static void	Machine_TSSInit ()
static void	Machine_SyscallInit ()
void	Machine_EarlyInit ()
static void	Machine_IdleThread (void *test)
void	Machine_Init ()
void	Machine_InitAP ()

Variables
static SegmentDescriptor	GDT [MAX_CPUS][GDT_MAX]
static PseudoDescriptor	GDTDescriptor [MAX_CPUS]
TaskStateSegment64	TSS [MAX_CPUS]
static char	df_stack [4096]

Macro Definition Documentation

GDT_MAX

#define GDT_MAX   8

Definition at line 36 of file machine.c.

Function Documentation

IDE_Init()

void IDE_Init

(

)

Definition at line 86 of file ide.c.

{
    ASSERT(sizeof(ATAIdentifyDevice) == 512);
 
    primary.base = IDE_PRIMARY_BASE;
    primary.devctl = IDE_PRIMARY_DEVCTL;
    Spinlock_Init(&primary.lock, "IDE Primary Controller Lock",
                  SPINLOCK_TYPE_NORMAL);
 
    if (!IDE_HasController(&primary)) {
        kprintf("IDE: No controller detected\n");
        return;
    }
 
    Spinlock_Lock(&primary.lock);
    IDE_Reset(&primary);
    IDE_Identify(&primary, 0);
    IDE_Identify(&primary, 1);
    Spinlock_Unlock(&primary.lock);
}

Here is the call graph for this function:

Here is the caller graph for this function:

KTime_Init()

void KTime_Init

(

)

Definition at line 26 of file ktime.c.

{
    Spinlock_Init(&ktimeLock, "KTime Lock", SPINLOCK_TYPE_NORMAL);
    ktimeLastEpoch = 0;
    ktimeLastTSC = 0;
    ticksPerSecond = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

KTimer_Init()

void KTimer_Init

(

)

Here is the caller graph for this function:

Loader_LoadInit()

void Loader_LoadInit

(

)

Loader_LoadInit –

The init process is created from the execution kernel thread that initializes the system. This function initializes the thread and process state then loads the init binary.

Definition at line 187 of file loader.c.

{
    int status;
    void *pg;
    VNode *initvn;
 
    pg = PAlloc_AllocPage();
    if (!pg)
        Panic("Not enough memory!");
 
    initvn = VFS_Lookup("/sbin/init");
    status = VFS_Open(initvn);
    if (status < 0)
        Panic("Loading init process failed!");
    status = VFS_Read(initvn, pg, 0, 1024);
    if (status < 0)
        Panic("Reading init process failed!");
 
    Thread *thr = Sched_Current();
 
    // Open stdin/out/err
    Handle *handle = Console_OpenHandle();
    Handle_Add(thr->proc, handle);
    handle = Console_OpenHandle();
    Handle_Add(thr->proc, handle);
    handle = Console_OpenHandle();
    Handle_Add(thr->proc, handle);
 
    /*
     * Load init binary
     */
    Loader_Load(thr, initvn, pg, 1024);
 
    VFS_Close(initvn);
 
    Log(loader, "Jumping to userspace\n");
 
    /*
     * Reload the page tables for the current process
     */
    PMap_LoadAS(thr->space); // Reload CR3
 
    /*
     * Pass in zero arguments with null pointers to init
     */
    uintptr_t ap[3];
    ap[0] = 0;
    ap[1] = 0;
    ap[2] = 0xDEADBEEF;
    uintptr_t rsp = MEM_USERSPACE_STKTOP - PGSIZE;
 
    Copy_Out(&ap[0], rsp, sizeof(uintptr_t)*3);
 
    /*
     * The last step is to return into userspace handing control to init.  We 
     * create a valid trap frame and return into userspace using Trap_Pop().
     */
    TrapFrame tf;
    memset(&tf, 0, sizeof(tf));
    tf.ds = SEL_UDS | 3;
    tf.rip = thr->proc->entrypoint;
    tf.cs = SEL_UCS | 3;
    tf.rsp = rsp;
    tf.ss = SEL_UDS | 3;
    tf.rflags = RFLAGS_IF;
    tf.rdi = rsp;
    Trap_Pop(&tf);
 
    /*
     * We should never reach this point!
     */
    Panic("Unreachable: Trap_Pop() returned!\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

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_GDTInit()

static void Machine_GDTInit ( )

static

Machine_GDTInit –

Configures the Global Descriptor Table (GDT) that lists all segments and privilege levels in x86. 64-bit mode uses flat 64-bit segments and doesn't support offsets and limits except for the special FS/GS segment registers.
We create four segments for the kernel code/data and user code/data.

Definition at line 53 of file machine.c.

{
    uint64_t offset;
    uint64_t tmp;
    int c = CPU();
 
    kprintf("Initializing GDT... "); // Caused pagefault??
 
    GDT[c][0] = 0x0;
    GDT[c][1] = 0x00AF9A000000FFFFULL; /* Kernel CS */
    GDT[c][2] = 0x00CF92000000FFFFULL; /* Kernel DS */
    GDT[c][3] = 0x0;
 
    // TSS
    offset = (uint64_t)&TSS[c];
    GDT[c][4] = sizeof(TaskStateSegment64);
    tmp = offset & 0x00FFFFFF;
    GDT[c][4] |= (tmp << 16);
    tmp = offset & 0xFF000000;
    GDT[c][4] |= (tmp << 56);
    GDT[c][4] |= 0x89ULL << 40;
    GDT[c][5] = offset >> 32;
 
    GDT[c][6] = 0x00AFFA000000FFFFULL; /* User CS */
    GDT[c][7] = 0x00CFF2000000FFFFULL; /* User DS */
 
    GDTDescriptor[c].off = (uint64_t)&GDT[c];
    GDTDescriptor[c].lim = 8*GDT_MAX - 1;
 
    lgdt(&GDTDescriptor[c]);
 
    kprintf("Done!\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Machine_IdleThread()

static void Machine_IdleThread ( void *  test )

static

Definition at line 157 of file machine.c.

{
    while (1) { enable_interrupts(); hlt(); }
}

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:

Machine_InitAP()

void Machine_InitAP

(

)

Machine_InitAP –

Shorter initialization routine for co-processors.

Definition at line 251 of file machine.c.

{
    Critical_Enter();
 
    // Setup CPU state
    Trap_InitAP();
    PMap_InitAP();
    Machine_GDTInit();
    Machine_TSSInit();
    Machine_SyscallInit();
    clts(); // Enable FPU/XMM
 
    // Setup LAPIC
    LAPIC_Init();
 
    // Boot processor
    MP_InitAP();
    Thread_InitAP();
    Critical_Exit();
 
    Machine_IdleThread(NULL);
}

Here is the call graph for this function:

Machine_SyscallInit()

static void Machine_SyscallInit ( )

static

Machine_SyscallInit –

Configure the model specific registers (MSRs) that specify how to transfer control to the operating system when the system call instruction is invoked.

Definition at line 128 of file machine.c.

{
    kprintf("Initializing Syscall... ");
 
    wrmsr(MSR_STAR, (uint64_t)SEL_KCS << 32 | (uint64_t)SEL_UCS << 48);
    wrmsr(MSR_LSTAR, 0);
    wrmsr(MSR_CSTAR, 0);
    wrmsr(MSR_SFMASK, 0);
 
    kprintf("Done!\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

Machine_TSSInit()

static void Machine_TSSInit ( )

static

Machine_TSSInit –

Configures the Task State Segment (TSS) that specifies the kernel stack pointer during an interrupt.

Definition at line 94 of file machine.c.

{
    int c = CPU();
 
    kprintf("Initializing TSS... ");
 
    TSS[c]._unused0 = 0;
    TSS[c]._unused1 = 0;
    TSS[c]._unused2 = 0;
    TSS[c]._unused3 = 0;
    TSS[c]._unused4 = 0;
    TSS[c].ist1 = ((uint64_t)&df_stack) + 4096;
    TSS[c].ist2 = 0x0;
    TSS[c].ist3 = 0x0;
    TSS[c].ist4 = 0x0;
    TSS[c].ist5 = 0x0;
    TSS[c].ist6 = 0x0;
    TSS[c].ist7 = 0x0;
    TSS[c].rsp0 = ((uint64_t)&df_stack) + 4096;
    TSS[c].rsp1 = 0;
    TSS[c].rsp2 = 0;
 
    ltr(SEL_TSS);
 
    kprintf("Done!\n");
}

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:

PAlloc_LateInit()

void PAlloc_LateInit

(

)

PAlloc_LateInit –

The late init call is made after the page tables are initialized using a small boot memory region (2nd 16MBs). This is where initialize the XMem region that represents the PageInfo array, and map memory into it.

Definition at line 71 of file palloc.c.

{
    void *pageInfoOld = pageInfoTable;
 
    pageInfoXMem = XMem_New();
    if (!XMem_Allocate(pageInfoXMem, pageInfoLength)) {
        Panic("Cannot back pageInfoTable!");
    }
 
    pageInfoTable = (PageInfo *)XMem_GetBase(pageInfoXMem);
    memcpy(pageInfoTable, pageInfoOld, pageInfoLength);
 
    // Free old pages
}

Here is the call graph for this function:

Here is the caller graph for this function:

PCI_Init()

void PCI_Init

(

)

Definition at line 27 of file pci.c.

{
    kprintf("PCI: Initializing ...\n");
    PCIScan();
    kprintf("PCI: Initialization Done!\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

PS2_Init()

void PS2_Init

(

)

Definition at line 274 of file ps2.c.

{
    uint8_t status, data;
 
    keyState = 0;
 
    outb(PS2_COMMAND_PORT, PS2_COMMAND_KBDDISABLE);
 
    while (1) {
        status = inb(PS2_STATUS_PORT);
        if ((status & PS2_STATUS_OBS) == 0)
            break;
 
        data = inb(PS2_DATA_PORT);
    }
 
    // Self test
    outb(PS2_COMMAND_PORT, PS2_COMMAND_SELFTEST);
    PS2Wait();
    data = inb(PS2_DATA_PORT);
    if (data != 0x55)
        kprintf("PS2: Controller test failed\n");
 
    outb(PS2_COMMAND_PORT, PS2_COMMAND_KBDENABLE);
 
    kbdHandler.irq = 1;
    kbdHandler.cb = &PS2_KeyboardIntr;
    kbdHandler.arg = NULL;
    psmHandler.irq = 12;
    psmHandler.cb = &PS2_MouseIntr;
    psmHandler.arg = NULL;
 
    IRQ_Register(1, &kbdHandler);
    IRQ_Register(12, &psmHandler);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RTC_Init()

void RTC_Init

(

)

Definition at line 23 of file rtc.c.

{
    uint64_t startTSC, stopTSC;
    UnixEpoch first, second;
 
    kprintf("RTC: Measuring CPU clock...\n");
 
    first = RTC_ReadTime();
    while (1) {
        second = RTC_ReadTime();
        if (first != second)
            break;
        first = second;
    }
    startTSC = Time_GetTSC();
 
    first = RTC_ReadTime();
    while (1) {
        second = RTC_ReadTime();
        if (first != second)
            break;
        first = second;
    }
    stopTSC = Time_GetTSC();
 
    kprintf("RTC: %lld Ticks Per Second: %lld\n", second, stopTSC - startTSC);
 
    KTime_SetTime(second, stopTSC, stopTSC - startTSC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

df_stack

char df_stack[4096]

static

Definition at line 42 of file machine.c.

GDT

SegmentDescriptor GDT[MAX_CPUS][GDT_MAX]

static

Definition at line 38 of file machine.c.

GDTDescriptor

PseudoDescriptor GDTDescriptor[MAX_CPUS]

static

Definition at line 39 of file machine.c.

TSS

TaskStateSegment64 TSS[MAX_CPUS]

Definition at line 40 of file machine.c.