loader.c File Reference

#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <sys/kassert.h>
#include <sys/sysctl.h>
#include <sys/kmem.h>
#include <sys/queue.h>
#include <sys/disk.h>
#include <sys/elf64.h>
#include <machine/amd64.h>
#include <machine/trap.h>
#include <machine/pmap.h>
#include <sys/thread.h>
#include <sys/spinlock.h>
#include <sys/loader.h>
#include <sys/vfs.h>

Include dependency graph for loader.c:

Go to the source code of this file.

Functions
Handle *	Console_OpenHandle ()
bool	Loader_CheckHeader (const Elf64_Ehdr *ehdr)
static void	LoaderLoadSegment (AS *as, VNode *vn, uintptr_t vaddr, uintptr_t offset, uintptr_t len)
static void	LoaderZeroSegment (AS *as, uintptr_t vaddr, uintptr_t len)
bool	Loader_Load (Thread *thr, VNode *vn, void *buf, uint64_t len)
void	Loader_LoadInit ()

Function Documentation

Console_OpenHandle()

Handle * Console_OpenHandle

(

)

Definition at line 200 of file console.c.

{
    Handle *handle = Handle_Alloc();
    if (!handle)
        return NULL;
 
    handle->read = &Console_Read;
    handle->write = &Console_Write;
    handle->flush = &Console_Flush;
    handle->close = &Console_Close;
 
    return handle;
}

Here is the caller graph for this function:

Loader_CheckHeader()

bool Loader_CheckHeader

(

const Elf64_Ehdr *

ehdr

)

Loader_CheckHeader –

Check that the program has a valid ELF header.

Definition at line 34 of file loader.c.

{
    if (ehdr->e_ident[EI_MAG0] != ELFMAG0 ||
        ehdr->e_ident[EI_MAG1] != ELFMAG1 ||
        ehdr->e_ident[EI_MAG2] != ELFMAG2 ||
        ehdr->e_ident[EI_MAG3] != ELFMAG3)
        return false;
 
    if (ehdr->e_ident[EI_CLASS] != ELFCLASS64) {
        return false;
    }
 
    if (ehdr->e_machine != EM_AMD64) {
        return false;
    }
 
    return true;
}

Here is the caller graph for this function:

Loader_Load()

bool Loader_Load	(	Thread *	thr,
		VNode *	vn,
		void *	buf,
		uint64_t	len
	)

Loader_Load –

Load the ELF binary into the process belonging to the thread.

Definition at line 131 of file loader.c.

{
    int i;
    const Elf64_Ehdr *ehdr;
    const Elf64_Phdr *phdr;
    AS *as = thr->space;
 
    ehdr = (const Elf64_Ehdr *)(buf);
    phdr = (const Elf64_Phdr *)(buf + ehdr->e_phoff);
 
    if (!Loader_CheckHeader(ehdr)) {
        Log(loader, "Not a valid executable!\n");
        return false;
    }
 
    Log(loader, "%8s %16s %8s %8s\n", "Offset", "VAddr", "FileSize", "MemSize");
    for (i = 0; i < ehdr->e_phnum; i++)
    {
        ASSERT(phdr[i].p_type != PT_DYNAMIC);
        if (phdr[i].p_type == PT_LOAD) {
            uint64_t va = phdr[i].p_vaddr;
            uint64_t memsz = phdr[i].p_memsz;
            Log(loader, "%08llx %016llx %08llx %08llx\n", phdr[i].p_offset,
                    phdr[i].p_vaddr, phdr[i].p_filesz, phdr[i].p_memsz);
 
            // Make sure it is page aligned
            va = va & ~(uint64_t)PGMASK;
            memsz += phdr[i].p_vaddr - va;
 
            Log(loader, "AllocMap %016llx %08llx\n", va, memsz);
            if (!PMap_AllocMap(as, va, memsz, PTE_W)) {
                // XXX: Cleanup!
                ASSERT(false);
                return false;
            }
        }
    }
 
    PMap_AllocMap(as, MEM_USERSPACE_STKBASE, MEM_USERSPACE_STKLEN, PTE_W);
 
    /* XXXFILLMEIN: Load the ELF segments. */
 
    /* Save the process entry point (i.e., _start) */
    thr->proc->entrypoint = ehdr->e_entry;
 
    return true;
}

Here is the call graph for this function:

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:

LoaderLoadSegment()

static void LoaderLoadSegment ( AS *  as, VNode *  vn, uintptr_t  vaddr, uintptr_t  offset, uintptr_t  len  )

static

LoaderLoadSegment –

Loads a single segment into the target address space. This function loads a single page at a time because it has to lookup the address mappings through the page tables.

Definition at line 61 of file loader.c.

{
    void *raddr;
 
    if ((vaddr % PGSIZE) != 0) {
        uintptr_t maxlen = PGSIZE - (vaddr % PGSIZE);
        uintptr_t rlen = maxlen < len ? maxlen : len;
 
        raddr = (void *)DMPA2VA(PMap_Translate(as, vaddr));
        VFS_Read(vn, raddr, offset, rlen);
        vaddr += rlen;
        offset += rlen;
        len -= rlen;
    }
 
    while (len > PGSIZE) {
        raddr = (void *)DMPA2VA(PMap_Translate(as, vaddr));
        VFS_Read(vn, raddr, offset, PGSIZE);
        vaddr += PGSIZE;
        offset += PGSIZE;
        len -= PGSIZE;
    }
 
    if (len > 0) {
        raddr = (void *)DMPA2VA(PMap_Translate(as, vaddr));
        VFS_Read(vn, raddr, offset, len);
    }
}

Here is the call graph for this function:

LoaderZeroSegment()

static void LoaderZeroSegment ( AS *  as, uintptr_t  vaddr, uintptr_t  len  )

static

LoaderZeroSegment –

Zeroes a segment of memory in the target address space. This is done one page a time while translating the virtual address to physical.

Definition at line 98 of file loader.c.

{
    void *raddr;
 
    if ((vaddr % PGSIZE) != 0) {
        uintptr_t maxlen = PGSIZE - (vaddr % PGSIZE);
        uintptr_t rlen = maxlen < len ? maxlen : len;
 
        raddr = (void *)DMPA2VA(PMap_Translate(as, vaddr));
        memset(raddr, 0, rlen);
        vaddr += rlen;
        len -= rlen;
    }
 
    while (len > PGSIZE) {
        raddr = (void *)DMPA2VA(PMap_Translate(as, vaddr));
        memset(raddr, 0, PGSIZE);
        vaddr += PGSIZE;
        len -= PGSIZE;
    }
 
    if (len > 0) {
        raddr = (void *)DMPA2VA(PMap_Translate(as, vaddr));
        memset(raddr, 0, len);
    }
}

Here is the call graph for this function: