loader.c

Go to the documentation of this file.

#include <kernel/fs/dentry.h>
#include <kernel/fs/file_table.h>
#include <kernel/fs/path.h>
#include <kernel/sched/loader.h>
#include <kernel/cpu/gdt.h>
#include <kernel/fs/vfs.h>
#include <kernel/log/log.h>
#include <kernel/mem/vmm.h>
#include <kernel/sched/process.h>
#include <kernel/sched/sched.h>
#include <kernel/sched/thread.h>
 
#include <errno.h>
#include <kernel/sched/wait.h>
#include <stdlib.h>
#include <string.h>
#include <sys/elf.h>
#include <sys/math.h>
#include <sys/proc.h>
 
static void loader_strv_free(char** array, uint64_t amount)
{
    if (array == NULL)
    {
        return;
    }
 
    for (uint64_t i = 0; i < amount; i++)
    {
        if (array[i] == NULL)
        {
            continue;
        }
        free(array[i]);
    }
    free((void*)array);
}
 
void loader_exec(const char* executable, char** argv, uint64_t argc)
{
    assert(executable != NULL);
    assert((argv != NULL && argc > 0) || ((argv == NULL || argv[0] == NULL) && argc == 0));
 
    // Generic error if a lower function fails without setting errno
    errno = ESPAWNFAIL;
 
    thread_t* thread = sched_thread();
    process_t* process = thread->process;
 
    file_t* file = NULL;
    void* fileData = NULL;
 
    file = vfs_open(PATHNAME(executable), process);
    if (file == NULL)
    {
        goto cleanup;
    }
 
    uint64_t fileSize = vfs_seek(file, 0, SEEK_END);
    vfs_seek(file, 0, SEEK_SET);
 
    fileData = malloc(fileSize);
    if (fileData == NULL)
    {
        goto cleanup;
    }
 
    uint64_t readSize = vfs_read(file, fileData, fileSize);
    if (readSize != fileSize)
    {
        goto cleanup;
    }
 
    Elf64_File elf;
    if (elf64_validate(&elf, fileData, fileSize) != 0)
    {
        goto cleanup;
    }
 
    Elf64_Addr minAddr = UINT64_MAX;
    Elf64_Addr maxAddr = 0;
    elf64_get_loadable_bounds(&elf, &minAddr, &maxAddr);
    uint64_t loadSize = maxAddr - minAddr;
 
    if (vmm_alloc(&process->space, (void*)minAddr, loadSize, PML_USER | PML_WRITE | PML_PRESENT, VMM_ALLOC_OVERWRITE) ==
        NULL)
    {
        goto cleanup;
    }
 
    elf64_load_segments(&elf, 0, 0);
 
    if (process_set_cmdline(process, argv, argc) == ERR)
    {
        goto cleanup;
    }
 
    char* rsp = (char*)thread->userStack.top;
    for (int64_t i = argc - 1; i >= 0; i--)
    {
        size_t len = strlen(argv[i]) + 1;
        rsp -= len;
        memcpy(rsp, argv[i], len);
 
        free(argv[i]);
        argv[i] = rsp;
    }
    rsp -= sizeof(char*);
    *((char**)rsp) = NULL;
    for (int64_t i = argc - 1; i >= 0; i--)
    {
        rsp -= sizeof(char*);
        *((char**)rsp) = argv[i];
        argv[i] = NULL;
    }
 
    // Disable interrupts, they will be enabled when we jump to user space.
    asm volatile("cli");
 
    memset(&thread->frame, 0, sizeof(interrupt_frame_t));
    thread->frame.rsp = ROUND_DOWN((uintptr_t)rsp - sizeof(uint64_t), 16);
    thread->frame.rip = elf.header->e_entry;
    thread->frame.rdi = argc;
    thread->frame.rsi = (uintptr_t)rsp;
    thread->frame.cs = GDT_CS_RING3;
    thread->frame.ss = GDT_SS_RING3;
    thread->frame.rflags = RFLAGS_INTERRUPT_ENABLE | RFLAGS_ALWAYS_SET;
 
    errno = EOK;
cleanup:
    if (file != NULL)
    {
        UNREF(file);
    }
    if (fileData != NULL)
    {
        free(fileData);
    }
    free((void*)executable);
    loader_strv_free(argv, argc);
    if (errno == EOK)
    {
        thread_jump(thread);
    }
    sched_process_exit(errno);
}
 
static void loader_entry(const char* executable, char** argv, uint64_t argc)
{
    thread_t* thread = sched_thread();
 
    WAIT_BLOCK(&thread->process->suspendQueue, !(atomic_load(&thread->process->flags) & PROCESS_SUSPENDED));
 
    loader_exec(executable, argv, argc);
}
 
SYSCALL_DEFINE(SYS_SPAWN, pid_t, const char** argv, spawn_flags_t flags)
{
    process_t* child = NULL;
    thread_t* childThread = NULL;
 
    uint64_t argc = 0;
    char** argvCopy = NULL;
    char* executable = NULL;
 
    if (argv == NULL)
    {
        errno = EINVAL;
        goto error;
    }
 
    thread_t* thread = sched_thread();
    process_t* process = thread->process;
 
    child = process_new(atomic_load(&process->priority));
    if (child == NULL)
    {
        goto error;
    }
 
    childThread = thread_new(child);
    if (childThread == NULL)
    {
        goto error;
    }
 
    if (thread_copy_from_user_string_array(thread, argv, &argvCopy, &argc) == ERR)
    {
        goto error;
    }
 
    if (argc == 0 || argvCopy[0] == NULL)
    {
        goto error;
    }
 
    executable = strdup(argvCopy[0]);
    if (executable == NULL)
    {
        goto error;
    }
 
    if (flags & SPAWN_SUSPEND)
    {
        atomic_fetch_or(&child->flags, PROCESS_SUSPENDED);
    }
 
    if (!(flags & SPAWN_EMPTY_FDS))
    {
        if (flags & SPAWN_STDIO_FDS)
        {
            if (file_table_copy(&child->fileTable, &process->fileTable, 0, 3) == ERR)
            {
                goto error;
            }
        }
        else
        {
            if (file_table_copy(&child->fileTable, &process->fileTable, 0, CONFIG_MAX_FD) == ERR)
            {
                goto error;
            }
        }
    }
 
    if (!(flags & SPAWN_EMPTY_NS))
    {
        if (namespace_set_parent(&child->ns, &process->ns) == ERR)
        {
            goto error;
        }
    }
 
    if (!(flags & SPAWN_EMPTY_ENV))
    {
        if (process_copy_env(child, process) == ERR)
        {
            goto error;
        }
    }
 
    if (!(flags & SPAWN_EMPTY_CWD))
    {
        path_t cwd = cwd_get(&process->cwd);
        cwd_set(&child->cwd, &cwd);
        path_put(&cwd);
    }
 
    // Call loader_exec(executable, argvCopy, argc)
    memset(&thread->frame, 0, sizeof(interrupt_frame_t));
    childThread->frame.rip = (uintptr_t)loader_entry;
    childThread->frame.rdi = (uintptr_t)executable;
    childThread->frame.rsi = (uintptr_t)argvCopy;
    childThread->frame.rdx = argc;
 
    childThread->frame.cs = GDT_CS_RING0;
    childThread->frame.ss = GDT_SS_RING0;
    childThread->frame.rsp = childThread->kernelStack.top;
    childThread->frame.rflags = RFLAGS_INTERRUPT_ENABLE | RFLAGS_ALWAYS_SET;
 
    pid_t volatile result = child->id; // Important to not deref after pushing the thread
    sched_submit(childThread);
    return result;
 
error:
    if (childThread != NULL)
    {
        thread_free(childThread);
    }
    if (child != NULL)
    {
        process_kill(child, errno);
    }
 
    free((void*)executable);
    loader_strv_free(argvCopy, argc);
    return ERR;
}
 
SYSCALL_DEFINE(SYS_THREAD_CREATE, tid_t, void* entry, void* arg)
{
    thread_t* thread = sched_thread();
    process_t* process = thread->process;
    space_t* space = &process->space;
 
    if (space_check_access(space, entry, sizeof(uint64_t)) == ERR)
    {
        return ERR;
    }
 
    // Dont check arg user space can use it however it wants
 
    thread_t* newThread = thread_new(process);
    if (newThread == NULL)
    {
        return ERR;
    }
 
    memset(&thread->frame, 0, sizeof(interrupt_frame_t));
    newThread->frame.rip = (uint64_t)entry;
    newThread->frame.rsp = newThread->userStack.top;
    newThread->frame.rbp = newThread->userStack.top;
    newThread->frame.rdi = (uint64_t)arg;
    newThread->frame.cs = GDT_CS_RING3;
    newThread->frame.ss = GDT_SS_RING3;
    newThread->frame.rflags = RFLAGS_INTERRUPT_ENABLE | RFLAGS_ALWAYS_SET;
 
    tid_t volatile result = newThread->id; // Important to not deref after pushing the thread
    sched_submit(newThread);
    return result;
}