loader.c

Go to the documentation of this file.

/*
 * Copyright (c) 2006-2023 Ali Mashtizadeh
 * All rights reserved.
 */
 
#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>
 
extern Handle *Console_OpenHandle();
 
bool
Loader_CheckHeader(const Elf64_Ehdr *ehdr)
{
    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;
}
 
static void
LoaderLoadSegment(AS *as, VNode *vn, uintptr_t vaddr,
                 uintptr_t offset, uintptr_t len)
{
    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);
    }
}
 
static void
LoaderZeroSegment(AS *as, uintptr_t vaddr, uintptr_t len)
{
    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);
    }
}
 
bool
Loader_Load(Thread *thr, VNode *vn, void *buf, uint64_t len)
{
    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;
}
 
void
Loader_LoadInit()
{
    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");
}